# Add Contacts to Chatbase Source: https://chatbase.co/docs/developer-guides/api/contacts/add-contacts-to-chatbase Add one or more contacts to a chatbot. ## Request ### URL ```url POST https://www.chatbase.co/api/v1/chatbots/{chatbotId}/contacts ``` ### Path Parameters The ID of the chatbot to add contacts to ### Headers Bearer `` application/json ### Body Parameters Array of contact objects to add. * Minimum: 1 contact * Maximum: 1000 contacts Unique identifier in your system Contact's name Contact's email address. Must be unique if provided. Contact's phone number Array of Stripe accounts for the contact. For more information, see [Contacts](/developer-guides/api/contacts/contact). Custom fields defined in your chatbot's schema. Each field must: * Exist in the custom attributes schema * Not be archived * Match the defined type * Unknown fields will be silently stripped ## Field Handling ### Default Fields Only the following default fields are recognized and stored: * `external_id` * `name` * `email` * `phonenumber` * `stripe_accounts` Any other fields outside of `custom_attributes` will be silently stripped from the data. ### Custom Attributes Fields under `custom_attributes` go through the following validation: 1. Each field is checked against the chatbot's custom attribute schema 2. Unknown fields (not in schema) are silently stripped 3. Fields that exist in the schema are validated: * Check if the field is archived (error if archived) * Validate the value against the field's type * Store the value if validation passes ### Example Request Body ```json { "users": [ { "external_id": "123456", "name": "John Doe", "email": "john.doe@example.com", "phonenumber": "+1234567890", "stripe_accounts": [ { "label": "Team 1", "stripe_id": "cus_1234567890" } ], "unknown_field": "will be stripped", "custom_attributes": { "company": "Acme Inc", // will be validated and stored "unknown_attr": "will be stripped", // not in schema, will be stripped "archived_field": "error", // will cause 400 error if archived "age": "invalid" // will cause 400 error if type is number } } ] } ``` ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message Array of created contact objects The unique identifier for the contact in Chatbase Your system's identifier for the contact Contact's name Contact's email address Contact's phone number Array of Stripe accounts for the contact. Object containing the stored custom attributes Unix timestamp of when the contact was created Unix timestamp of when the contact was last updated ```json { "message": "Success", "data": { "created": [ { "id": "123e4567-e89b-12d3-a456-426614174000", "external_id": "123456", "name": "John Doe", "email": "john.doe@example.com", "phonenumber": "+1234567890", "stripe_accounts": [ { "label": "Team 1", "stripe_id": "cus_1234567890" } ], "custom_attributes": { "company": "Acme Inc" }, "created_at": 1571672154, "updated_at": 1571672154 } ] } } ``` ### Error Responses #### 400 Bad Request * Invalid request body * Maximum contacts limit reached * Invalid custom attribute value type * Archived custom attribute used ```json { "message": "Invalid request body", "issues": [ { "field": "custom_attributes.age", "message": "Expected number, received string" } ] } ``` #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot not found ```json { "message": "Chatbot not found" } ``` #### 409 Conflict * Email already exists ```json { "message": "Email already exists" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` ## Code Examples ```bash cURL curl -X POST 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{ "users": [ { "external_id": "123456", "name": "John Doe", "email": "john.doe@example.com", "phonenumber": "+1234567890", "custom_attributes": { "company": "Acme Inc" } } ] }' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts', { method: 'POST', headers: { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, body: JSON.stringify({ users: [{ external_id: "123456", name: "John Doe", email: "john.doe@example.com", phonenumber: "+1234567890", custom_attributes: { company: "Acme Inc" } }] }) } ); const data = await response.json(); ``` ```python Python import requests response = requests.post( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts', headers={ 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, json={ 'users': [{ 'external_id': '123456', 'name': 'John Doe', 'email': 'john.doe@example.com', 'phonenumber': '+1234567890', 'custom_attributes': { 'company': 'Acme Inc' } }] } ) data = response.json() ``` # Contact Source: https://chatbase.co/docs/developer-guides/api/contacts/contact Contact Object represent your saved contacts in Chatbase. ## Contact Object The unique identifier for the contact. Generated by Chatbase. The unique identifier for the contact provided by your system. The contact's name. The contact's email address. Must be unique if provided. The contact's phone number (e.g. +1234567890). An array of Stripe account objects. Each object must include a label and at least one of stripe\_id or stripe\_email. The display label for the Stripe account. This label is displayed in the chat when a user has multiple Stripe accounts. If the user has only one Stripe account, any string can be used. Stripe Customer ID The email associated with the Stripe account. The display label for the Stripe account. This label is displayed in the chat when a user has multiple Stripe accounts. If the user has only one Stripe account, any string can be used. Stripe Customer ID The email associated with the Stripe account. The Unix timestamp when the contact was created in Chatbase. The Unix timestamp when the contact was last updated in Chatbase. A JSON object containing custom attributes for the contact. For more information, see [Custom Attributes](/developer-guides/api/contacts/custom-attributes). ## Example Contact Object ```json { "id": "123e4567-e89b-12d3-a456-426614174000", "external_id": "kX2b8YpI-jRmN3vQ5", "name": "John Doe", "email": "john.doe@example.com", "phonenumber": "+1234567890", "stripe_accounts": [ { "label": "Team 1", "stripe_id": "cus_1234567890", "stripe_email": "john.doe@example.com" }, { "label": "Team 2", "stripe_id": "cus_9876543210" }, { "label": "Team 3", "stripe_email": "joe.doe@example.com" } ], "custom_attributes": { "age": 30, "location": "New York" }, "created_at": 1571672154, "updated_at": 1571672154 } ``` # Create Custom Attribute Source: https://chatbase.co/docs/developer-guides/api/contacts/create-custom-attribute Create a new custom attribute for contacts in a chatbot. ## Request ### URL ```url POST https://www.chatbase.co/api/v1/chatbots/{chatbotId}/custom-attributes ``` ### Path Parameters The ID of the chatbot to create the custom attribute for ### Headers Bearer `` application/json ### Body Parameters The name of the custom attribute. Must be unique within the chatbot. * Must only contain lowercase letters, numbers, and underscores * Must start with a letter * Once created, cannot be deleted from the schema The type of the custom attribute. Cannot be changed after creation. Allowed values: `text`, `number`, `boolean`, `date` The display label for the custom attribute A description of the custom attribute ```json { "name": "company", "type": "text", "label": "Company Name", "description": "User's company name" } ``` ## Important Notes 1. Custom attributes cannot be deleted once created 2. If you need to discontinue use of a field, you can archive it using the update endpoint 3. Archived fields: * Cannot be used when creating new contacts * Cannot be updated in existing contacts * Can only be set to null * Still return their existing values in responses 4. Choose field names carefully as they are permanent 5. Plan your schema design thoroughly before creating attributes ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message The unique identifier for the custom attribute The type of the attribute. One of: `text`, `number`, `boolean`, `date` The display label for the attribute Description of the attribute Whether the attribute is archived. If true, the attribute cannot be used for new or updated values ```json { "message": "Success", "data": { "name": "company", "type": "text", "label": "Company Name", "description": "User's company name", "archived": false } } ``` ### Error Responses #### 400 Bad Request * Invalid request body * Reserved field name used * Invalid field name format ```json { "message": "Invalid request body", "issues": [ { "field": "type", "message": "Invalid type. Must be one of: text, number, boolean, date" } ] } ``` #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot not found ```json { "message": "Chatbot not found" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` #### 500 Internal Server Error * Server error occurred ```json { "message": "Error creating contact custom attributes" } ``` ## Code Examples ```bash cURL curl -X POST 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{ "name": "company", "type": "text", "label": "Company Name", "description": "User'\''s company name" }' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes', { method: 'POST', headers: { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'company', type: 'text', label: 'Company Name', description: "User's company name" }) } ); const data = await response.json(); ``` ```python Python import requests response = requests.post( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes', headers={ 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, json={ 'name': 'company', 'type': 'text', 'label': 'Company Name', 'description': "User's company name" } ) data = response.json() ``` # Custom Attributes Source: https://chatbase.co/docs/developer-guides/api/contacts/custom-attributes Custom Attributes are the additional fields you can add to your contacts. Custom Attributes are the additional fields you can add to your contacts in Chatbase. Each chatbot has its own custom attribute schema that defines what additional data can be stored for contacts. ## Schema Management ### Field Lifecycle * Custom attributes, once created, cannot be deleted from the schema * Fields can be archived to prevent new usage while preserving historical data * When a field is archived: * New contacts cannot be created with this field * Existing contacts cannot update this field * The field can only be set to null * Existing values are preserved and still readable ## Available Endpoints The Custom Attributes API provides the following endpoints: * [List Custom Attributes](/developer-guides/api/contacts/list-custom-attributes): Retrieve all custom attributes for a chatbot * [Create Custom Attribute](/developer-guides/api/contacts/create-custom-attribute): Add a new custom attribute to a chatbot ## Available Types For storing text values For storing numeric values For storing true/false values Data of type **boolean** passed to the contacts API will be coerced to a boolean. For example, a string of value "true" will be converted to a `true`. And a string of value "false" will be converted to a `false`. Also, a number of value `0` will be converted to a `false`. And a number of value `1` will be converted to a `true`. For storing dates in ISO 8601 format Data of type **date** passed to the contacts API will be coerced to a date. Supporting formats exactly supported by [Javascript Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date). ## Custom Attribute Object The unique identifier for the custom attribute The type of the attribute. One of: `text`, `number`, `boolean`, `date` The display label for the attribute Description of the attribute Whether the attribute is archived. If true, the attribute cannot be used for new or updated values ## Using Custom Attributes Once you've created custom attributes, you can: 1. Add values for these attributes when [creating contacts](/developer-guides/api/contacts/add-contacts-to-chatbase) 2. Update values through the [update contact](/developer-guides/api/contacts/update-contact) endpoint 3. View values when [listing contacts](/developer-guides/api/contacts/list-contacts) or [getting a single contact](/developer-guides/api/contacts/get-contact) ### Example ```json { "custom_attributes": { "company": "Acme Inc", // text type "age": 25, // number type "is_active": true, // boolean type "join_date": "2023-01-15", // date type "unknown_field": "value" // will be stripped out } } ``` ## Field Handling ### Custom Attributes Validation Fields under the `custom_attributes` object go through the following validation: 1. Field existence check against the schema, non-existent fields are silently removed 2. Archival status check (archived fields are rejected) 3. Type validation against the defined type in schema 4. Value storage if all checks pass ## Best Practices 1. Choose descriptive names for your custom attributes 2. Use appropriate types for your data 3. Provide clear descriptions to help other team members understand the purpose of each attribute 4. Keep the number of custom attributes manageable 5. Plan your schema carefully as fields cannot be removed # Delete Contact Source: https://chatbase.co/docs/developer-guides/api/contacts/delete-contact Delete a contact from a chatbot. ## Request ### URL ```url DELETE https://www.chatbase.co/api/v1/chatbots/{chatbotId}/contacts/{contactId} ``` ### Path Parameters The ID of the chatbot the contact belongs to The ID of the contact to delete ### Headers Bearer `` ## Response ### Success Response * **Status**: 204 No Content No content returned on successful deletion ### Error Responses #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot or contact not found ```json { "message": "Contact not found" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` ## Code Examples ```bash cURL curl -X DELETE 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000' \ -H 'Authorization: Bearer ' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000', { method: 'DELETE', headers: { 'Authorization': 'Bearer ' } } ); if (response.status === 204) { console.log('Contact deleted successfully'); } ``` ```python Python import requests response = requests.delete( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000', headers={ 'Authorization': 'Bearer ' } ) if response.status_code == 204: print('Contact deleted successfully') ``` # Get Contact Source: https://chatbase.co/docs/developer-guides/api/contacts/get-contact Retrieve a single contact by ID. ## Request ### URL ```url GET https://www.chatbase.co/api/v1/chatbots/{chatbotId}/contacts/{contactId} ``` ### Path Parameters The ID of the chatbot the contact belongs to The ID of the contact to retrieve ### Headers Bearer `` ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message The unique identifier for the contact in Chatbase Your system's identifier for the contact Contact's name Contact's email address. Must be unique if provided. Contact's phone number (e.g. +1234567890) Object containing custom attributes for the contact. For more information, see [Custom Attributes](/developer-guides/api/contacts/custom-attributes). Unix timestamp when the contact was created in Chatbase Unix timestamp when the contact was last updated in Chatbase ```json { "message": "Success", "data": { "id": "123e4567-e89b-12d3-a456-426614174000", "external_id": "kX2b8YpI-jRmN3vQ5", "name": "John Doe", "email": "john.doe@example.com", "phonenumber": "+1234567890", "custom_attributes": { "age": 30, "location": "New York" }, "created_at": 1571672154, "updated_at": 1571672154 } } ``` ### Error Responses #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot or contact not found ```json { "message": "Contact not found" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` ## Code Examples ```bash cURL curl -X GET 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000' \ -H 'Authorization: Bearer ' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000', { method: 'GET', headers: { 'Authorization': 'Bearer ' } } ); const data = await response.json(); ``` ```python Python import requests response = requests.get( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000', headers={ 'Authorization': 'Bearer ' } ) data = response.json() ``` # List Contacts Source: https://chatbase.co/docs/developer-guides/api/contacts/list-contacts Retrieve a list of contacts for a chatbot with pagination support. ## Request ### URL ```url GET https://www.chatbase.co/api/v1/chatbots/{chatbotId}/contacts ``` ### Path Parameters The ID of the chatbot to retrieve contacts from ### Headers Bearer `` ### Query Parameters Number of contacts per page * Default: 100 * Minimum: 10 * Maximum: 1000 The page number for pagination * Default: 1 * Minimum: 1 ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message Array of contact objects The unique identifier for the contact in Chatbase Your system's identifier for the contact Contact's name Contact's email address. Must be unique if provided. Contact's phone number (e.g. +1234567890) Array of Stripe accounts for the contact. For more information, see [Contacts](/developer-guides/api/contacts/contact). Object containing custom attributes for the contact. For more information, see [Custom Attributes](/developer-guides/api/contacts/custom-attributes). Unix timestamp when the contact was created in Chatbase Unix timestamp when the contact was last updated in Chatbase Total number of contacts available Current page number Number of contacts per page Total number of pages available ```json { "message": "Success", "data": [ { "id": "123e4567-e89b-12d3-a456-426614174000", "external_id": "kX2b8YpI-jRmN3vQ5", "name": "John Doe", "email": "john.doe@example.com", "phonenumber": "+1234567890", "stripe_accounts": [ { "label": "Team 1", "stripe_id": "cus_1234567890", "stripe_email": "john.doe@example.com" } ], "custom_attributes": { "age": 30, "location": "New York" }, "created_at": 1571672154, "updated_at": 1571672154 } // ... more contacts ], "total": 150, "pages": { "page": 1, "per_page": 100, "total_pages": 2 } } ``` ### Error Responses #### 400 Bad Request * Invalid page number or per\_page value * Page number out of range ```json { "message": "Invalid request parameters", "issues": [ { "field": "per_page", "message": "Number must be greater than or equal to 10" } ] } ``` #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot not found ```json { "message": "Chatbot not found" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` #### 500 Internal Server Error * Server error occurred ```json { "message": "Error retrieving chatbot contacts" } ``` ## Code Examples ```bash cURL curl -X GET 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts?per_page=100&page=1' \ -H 'Authorization: Bearer ' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts?per_page=100&page=1', { method: 'GET', headers: { 'Authorization': 'Bearer ' } } ); const data = await response.json(); ``` ```python Python import requests response = requests.get( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts', headers={ 'Authorization': 'Bearer ' }, params={ 'per_page': 100, 'page': 1 } ) data = response.json() ``` # List Custom Attributes Source: https://chatbase.co/docs/developer-guides/api/contacts/list-custom-attributes Retrieve all custom attributes defined for a chatbot. ## Request ### URL ```url GET https://www.chatbase.co/api/v1/chatbots/{chatbotId}/custom-attributes ``` ### Path Parameters The ID of the chatbot to retrieve custom attributes from ### Headers Bearer `` ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message Array of custom attribute objects The unique identifier for the custom attribute The type of the attribute. One of: `text`, `number`, `boolean`, `date` The display label for the attribute Description of the attribute Whether the attribute is archived. If true, the attribute cannot be used for new or updated values ```json { "message": "Success", "data": [ { "name": "company", "type": "text", "label": "Company Name", "description": "User's company name", "archived": false }, { "name": "age", "type": "number", "label": "Age", "description": "User's age", "archived": false }, { "name": "old_field", "type": "text", "label": "Deprecated Field", "description": "This field is no longer in use", "archived": true } ] } ``` The `archived` field indicates whether the custom attribute is active: * `false`: The attribute is active and can be used * `true`: The attribute is archived and cannot be used for new or updated values ### Error Responses #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot not found ```json { "message": "Chatbot not found" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` #### 500 Internal Server Error * Server error occurred ```json { "message": "Error getting contact custom attributes schema" } ``` ## Code Examples ```bash cURL curl -X GET 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes' \ -H 'Authorization: Bearer ' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes', { method: 'GET', headers: { 'Authorization': 'Bearer ' } } ); const data = await response.json(); ``` ```python Python import requests response = requests.get( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes', headers={ 'Authorization': 'Bearer ' } ) data = response.json() ``` # Update Contact Source: https://chatbase.co/docs/developer-guides/api/contacts/update-contact Update an existing contact's information. ## Request ### URL ```url PATCH https://www.chatbase.co/api/v1/chatbots/{chatbotId}/contacts/{contactId} ``` ### Path Parameters The ID of the chatbot the contact belongs to The ID of the contact to update ### Headers application/json Bearer `` ### Body Parameters Object containing the contact information to update Contact's name Contact's email address. Must be unique if provided. Contact's phone number (e.g. +1234567890) Array of Stripe accounts for the contact. For more information, see [Contacts](/developer-guides/api/contacts/contact). Custom attributes to update for the contact. For more information, see [Custom Attributes](/developer-guides/api/contacts/custom-attributes). ```json { "data": { "name": "John Smith", "email": "john.smith@example.com", "phonenumber": "+1234567890", "custom_attributes": { "age": 31, "location": "Los Angeles" } } } ``` ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message The unique identifier for the contact in Chatbase Your system's identifier for the contact Contact's name Contact's email address. Must be unique if provided. Contact's phone number (e.g. +1234567890) Object containing custom attributes for the contact. For more information, see [Custom Attributes](/developer-guides/api/contacts/custom-attributes). Unix timestamp when the contact was created in Chatbase Unix timestamp when the contact was last updated in Chatbase ```json { "message": "Success", "data": { "id": "123e4567-e89b-12d3-a456-426614174000", "external_id": "kX2b8YpI-jRmN3vQ5", "name": "John Smith", "email": "john.smith@example.com", "phonenumber": "+1234567890", "custom_attributes": { "age": 31, "location": "Los Angeles" }, "created_at": 1571672154, "updated_at": 1571672154 } } ``` ### Error Responses #### 400 Bad Request * Invalid request body or custom attributes ```json { "message": "Invalid request body", "issues": [ { "field": "custom_attributes.age", "message": "Expected number, received string" } ] } ``` #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot or contact not found ```json { "message": "Contact not found" } ``` #### 409 Conflict * Email already exists for another contact ```json { "message": "Email already exists" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` ## Code Examples ```bash cURL curl -X PATCH 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{ "data": { "name": "John Smith", "custom_attributes": { "age": 31, "location": "Los Angeles" } } }' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000', { method: 'PATCH', headers: { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, body: JSON.stringify({ data: { name: 'John Smith', custom_attributes: { age: 31, location: 'Los Angeles' } } }) } ); const data = await response.json(); ``` ```python Python import requests response = requests.patch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/contacts/123e4567-e89b-12d3-a456-426614174000', headers={ 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, json={ 'data': { 'name': 'John Smith', 'custom_attributes': { 'age': 31, 'location': 'Los Angeles' } } } ) data = response.json() ``` # Update Custom Attribute Source: https://chatbase.co/docs/developer-guides/api/contacts/update-custom-attribute Update an existing custom attribute's properties. ## Request ### URL ```url PUT https://www.chatbase.co/api/v1/chatbots/{chatbotId}/custom-attributes/{name} ``` ### Path Parameters The ID of the chatbot the custom attribute belongs to The name of the custom attribute to update ### Headers application/json Bearer `` ### Body Parameters The new display label for the custom attribute The new description for the custom attribute Whether the custom attribute should be archived Default: false ```json { "label": "Updated Label", "description": "Updated description", "archived": false } ``` ## Response ### Success Response * **Status**: 200 OK * **Content-Type**: application/json Success message The unique identifier for the custom attribute The type of the attribute. One of: `text`, `number`, `boolean`, `date` The display label for the attribute Description of the attribute Whether the attribute is archived. If true, the attribute cannot be used for new or updated values ```json { "message": "Success", "data": { "name": "company", "type": "text", "label": "Updated Label", "description": "Updated description", "archived": false } } ``` ### Error Responses #### 400 Bad Request * Invalid request body ```json { "message": "Invalid request body" } ``` #### 401 Unauthorized * Invalid or missing API key ```json { "message": "Unauthorized access" } ``` #### 404 Not Found * Chatbot or custom attribute not found ```json { "message": "Custom attribute not found" } ``` #### 429 Too Many Requests * Rate limit exceeded ```json { "message": "Rate limit exceeded" } ``` ## Code Examples ```bash cURL curl -X PUT 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes/company' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{ "label": "Updated Label", "description": "Updated description", "archived": false }' ``` ```javascript Node.js const response = await fetch( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes/company', { method: 'PUT', headers: { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, body: JSON.stringify({ label: 'Updated Label', description: 'Updated description', archived: false }) } ); const data = await response.json(); ``` ```python Python import requests response = requests.put( 'https://www.chatbase.co/api/v1/chatbots/5ba682d23d7cf92bef87bfd4/custom-attributes/company', headers={ 'Authorization': 'Bearer ', 'Content-Type': 'application/json' }, json={ 'label': 'Updated Label', 'description': 'Updated description', 'archived': False } ) data = response.json() ``` # null Source: https://chatbase.co/docs/developer-guides/api/create-a-chatbot The Chatbot Creation API allows you to create a new chatbot by making a `POST` request to the `/api/v1/create-chatbot` endpoint. ## Endpoint ``` POST https://www.chatbase.co/api/v1/create-chatbot ``` ## Request Headers The API request must include the following headers: * `Authorization: Bearer ` - The secret key for authenticating the API request. * `Content-Type: application/json` - The content type of the request payload. ## Request Body The request body should contain the following parameters: * `chatbotName` (string, required): The name of the chatbot to be created. * `sourceText` (string, optional): The text data for the chatbot. This field is subject to the character limit based on your plan ## Example Request ```javascript const res = await fetch('https://www.chatbase.co/api/v1/create-chatbot', { method: 'POST', headers: { Authorization: `Bearer `, 'Content-Type': 'application/json', }, body: JSON.stringify({ chatbotName: 'example chatbot', sourceText: 'Source text......', }), }) const data = await res.json() console.log(data) // {chatbotId: 'exampleId-123'} ``` ```python import requests import json url = 'https://www.chatbase.co/api/v1/create-chatbot' headers = { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' } data = { 'chatbotName': 'example chatbot', 'sourceText': 'Source text......' } response = requests.post(url, headers=headers, data=json.dumps(data)) data = response.json() print(data) # {'chatbotId': 'exampleId-123'} ``` ```shell curl https://www.chatbase.co/api/v1/create-chatbot \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer ' \ -d '{"urlsToScrape": ["https://www.chatbase.co/docs/chat", "https://www.chatbase.co/docs/create-chatbot"], "chatbotName": "Chatbase"}' ``` ```http POST /api/create-chatbot HTTP/1.1 Host: https://www.chatbase.co/api/v1/create-chatbot Authorization: Bearer Content-Type: application/json { "chatbotName": "example chatbot", "sourceText": "Source text......" } ``` ## Response The API response will be a JSON object with the following structure: ```json { "chatbotId": "exampleId-123" } ``` The `chatbotId` field in the response contains the unique identifier assigned to the created chatbot. ## Error Handling If there are any errors during the API request, appropriate HTTP status codes will be returned along with error messages in the response body. Make sure to handle these errors gracefully in your application. That's it! You should now be able to create a chatbot using the create API. # null Source: https://chatbase.co/docs/developer-guides/api/delete-a-chatbot The Chatbot Deletion API allows you to delete a chatbot by providing the chatbot ID. This API can be used to remove a chatbot and its associated data from the system. ## Endpoint ``` DELETE https://www.chatbase.co/api/v1/delete-chatbot ``` ## Request Headers The API request must include the following header: * `Authorization: Bearer ` - The secret key for authenticating the API request. ## Query Parameters The request URL should include the following query parameter: * `chatbotId` (required): A unique identifier for the chatbot that you want to delete. It helps identify the specific chatbot to be removed from the system. ### Example Request URL ``` https://www.chatbase.co/api/v1/delete-chatbot?chatbotId=exampleId-123 ``` ## Response The API response will be a JSON object with the following structure: ```json { "message": "Deleted successfully" } ``` The `message` field in the response indicates the success of the chatbot deletion operation. ## Examples ```javascript JavaScript const res = await fetch( 'https://www.chatbase.co/api/v1/delete-chatbot?chatbotId=exampleId-123', { method: 'DELETE', headers: { Authorization: `Bearer `, }, } ) const data = await res.json() console.log(data) // {message: 'Deleted successfully'} ``` ```python import requests url = 'https://www.chatbase.co/api/v1/delete-chatbot' params = {'chatbotId': 'exampleId-123'} headers = { 'Authorization': 'Bearer ' } response = requests.delete(url, params=params, headers=headers) data = response.json() print(data) # {'message': 'Deleted successfully'} ``` ```shell curl "https://www.chatbase.co/api/v1/delete-chatbot?chatbotId=exampleId-123" \ --request "DELETE" \ -H 'Authorization: Bearer ' ``` ```http DELETE /api/v1/delete-chatbot?chatbotId=exampleId-123 HTTP/1.1 Host: www.chatbase.co Authorization: Bearer ``` ## Error Handling If there are any errors during the API request, appropriate HTTP status codes will be returned along with error messages in the response body. Make sure to handle these errors gracefully in your application. That's it! You should now be able to delete a chatbot using the Chatbot Deletion API. # null Source: https://chatbase.co/docs/developer-guides/api/delete-chatbot-icon The Delete Chatbot Icon API endpoint allows you to delete the icon associated with a specific chatbot. ## Endpoint ``` DELETE https://www.chatbase.co/api/v1/delete-chatbot-icon ``` ## Request Parameters * `chatbotId` (string, required): A unique identifier for the chatbot for which you want to delete the icon. ## Example Request ```shell curl --request DELETE \ --url https://www.chatbase.co/api/v1/delete-chatbot-icon \ --header 'accept: application/json' ``` ```python Python import requests url = "https://www.chatbase.co/api/v1/delete-chatbot-icon" headers = {"accept": "application/json"} response = requests.delete(url, headers=headers) print(response.text) ``` ```javascript const options = {method: 'DELETE', headers: {accept: 'application/json'}} fetch('https://www.chatbase.co/api/v1/delete-chatbot-icon', options) .then((response) => response.json()) .then((response) => console.log(response)) .catch((err) => console.error(err)) ``` ```Text HTTP DELETE /api/v1/delete-chatbot-icon HTTP/1.1 Accept: application/json Host: www.chatbase.co ``` ## Response * **200**: Reply confirming the successful deletion of the Chatbot icon. * **400**: If the chatbot ID is missing. * **401**: If the request is unauthorized. * **404**: If the chatbot cannot be found. * **500**: If there is an internal server error. ### Example Response ```json { "message": "Chatbot icon deleted successfully." } ``` The Delete Chatbot Icon API endpoint provides a way to remove the icon associated with a chatbot. Upon successful deletion, a confirmation message is returned in the response. # null Source: https://chatbase.co/docs/developer-guides/api/delete-chatbot-profile-picture The Delete Chatbot Profile Picture API endpoint allows you to delete the profile picture of a specific chatbot. ## Endpoint ``` DELETE https://www.chatbase.co/api/v1/delete-chatbot-profile-picture ``` ## Request Headers The API request must include the following headers: * `Authorization: Bearer ` - The secret key for authenticating the API request. * `Accept: application/json` - The accepted response content type. ## Request Parameters * `chatbotId` (string, required): A unique identifier for the chatbot you want to delete the profile picture for. ## Example Request ```shell curl --request DELETE \ --url 'https://www.chatbase.co/api/v1/delete-chatbot-profile-picture?chatbotId=%5BYour%20Chatbot%20ID%5D' \ --header 'accept: application/json' ``` ```Text JavaScript const options = {method: 'DELETE', headers: {accept: 'application/json'}}; fetch('https://www.chatbase.co/api/v1/delete-chatbot-profile-picture?chatbotId=%5BYour%20Chatbot%20ID%5D', options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err)); ``` ```http DELETE /api/v1/delete-chatbot-profile-picture?chatbotId=%5BYour%20Chatbot%20ID%5D HTTP/1.1 Accept: application/json Host: www.chatbase.co ``` ```Text Python import requests url = "https://www.chatbase.co/api/v1/delete-chatbot-profile-picture?chatbotId=%5BYour%20Chatbot%20ID%5D" headers = {"accept": "application/json"} response = requests.delete(url, headers=headers) print(response.text) ``` ## Response * **200**: Reply confirming the successful deletion of the chatbot's profile picture. * **400**: If the chatbot ID is missing. * **401**: If the request is unauthorized. * **404**: If the chatbot cannot be found. * **500**: If there is an internal server error. The Delete Chatbot Profile Picture API endpoint provides a way to remove the profile picture of a chatbot. Upon successful deletion, a confirmation message is returned in the response. # null Source: https://chatbase.co/docs/developer-guides/api/get-chatbots The Get Chatbots API endpoint allows you to retrieve a list of all chatbots associated with your API key. ## Endpoint ``` GET https://www.chatbase.co/api/v1/get-chatbots ``` ## Request Headers The API request must include the following headers: * `Authorization: Bearer ` - The secret key for authenticating the API request. * `Accept: application/json` - The accepted response content type. ## Example Request ```python import requests url = "https://www.chatbase.co/api/v1/get-chatbots" headers = {"accept": "application/json"} response = requests.get(url, headers=headers) print(response.text) ``` ```http GET /api/v1/get-chatbots HTTP/1.1 Accept: application/json Host: www.chatbase.co ``` ```javascript const options = {method: 'GET', headers: {accept: 'application/json'}} fetch('https://www.chatbase.co/api/v1/get-chatbots', options) .then((response) => response.json()) .then((response) => console.log(response)) .catch((err) => console.error(err)) ``` ```shell curl --request GET \ --url https://www.chatbase.co/api/v1/get-chatbots \ --header 'accept: application/json' ``` ## Response * **200**: Returns an array `chatbots[]` containing each chatbot's parameters. * **401**: If the request is unauthorized. * **500**: If there is an internal server error. The Get Chatbots API endpoint provides a way to retrieve a list of all chatbots associated with your API key. Each entry in the response array contains all parameters of the respective chatbot. # null Source: https://chatbase.co/docs/developer-guides/api/get-conversations The Get Conversations API endpoint allows you to retrieve conversations from a specific chatbot. You can filter conversations based on various criteria, including the chatbot's ID, date range, and filtered sources. ## Endpoint ``` GET https://www.chatbase.co/api/v1/get-conversations ``` ## Request Headers The API request must include the following header: * `Authorization: Bearer ` - The secret key for authenticating the API request. ## Request Parameters * `chatbotId` (string, required): The ID of the target chatbot from which you want to retrieve conversations (found in the chatbot settings). * `filteredSources` (string, optional): A comma-separated string of sources to be filtered for the chatbot's conversation. The sources can be any of the following:
* "API," - "Chatbase site," - "Instagram," - "Messenger," - "Slack," - "Unspecified," * "WhatsApp," - "Widget or Iframe"
* `startDate` (string, optional): A string representing the start date of the range within which conversations are to be fetched. The date string is expected to be in the "Year-Month-Day" format (e.g 2023-07-10 not 2023-7-10)`endDate` (string, optional): A string representing the end date of the range within which conversations are to be fetched. The date string is expected to be in the "Year-Month-Day" format (e.g 2023-07-13 not 2023-7-13). * `page` (string, optional, default=1): A string representing the page number of the results, used for pagination. * `size` (string, optional, default=10, max=100): A string representing the number of results per page, also used for pagination. ## Request Example ```shell curl --request GET \ --url 'https://www.chatbase.co/api/v1/get-conversations?chatbotId=&startDate=2023-01-01&endDate=2023-12-12&page=1&size=20' \ --header 'accept: application/json' ``` ```Text Javascript const options = {method: 'GET', headers: {accept: 'application/json'}}; fetch('https://www.chatbase.co/api/v1/get-conversations?chatbotId=&startDate=2023-01-01&endDate=2023-12-12&page=1&size=20', options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err)); ``` ```Text Python import requests url = "https://www.chatbase.co/api/v1/get-conversations?chatbotId=&startDate=2023-01-01&endDate=2023-12-12&page=1&size=20" headers = {"accept": "application/json"} response = requests.get(url, headers=headers) print(response.text) ``` ## Response * **200**: Returns an array `data[]` with conversations matching the provided filters. Each conversation object has the following structure: * `id` (string): The ID of the conversation. * `created_at` (string): The timestamp of when the conversation was created. * `messages` (array): An array containing message objects with role and content properties. * `chatbot_id` (string): The ID of the chatbot associated with the conversation. * `customer` (string): The customer or user identifier. * `source` (string): The source of the conversation. * **400**: If the provided start or end dates are invalid. * **401**: If the request is unauthorized. * **404**: If the chatbot ID is invalid. * **500**: If there is an internal server error. ### Example Response ```json { "data": [ { "id": "string", "created_at": "string", "messages": [ { "role": "string", "content": "string" } ], "chatbot_id": "string", "customer": "string", "source": "string" } ] } ``` The Get Conversations API endpoint provides a way to retrieve conversations from a chatbot based on specified filters. The response includes an array of conversations, each with its relevant details. # null Source: https://chatbase.co/docs/developer-guides/api/get-leads The Get Leads API endpoint allows you to retrieve leads generated from a chatbot's conversations. By using this endpoint, you can obtain names, phone numbers, and emails from users who interact with your chatbots. ## Endpoint ``` GET https://www.chatbase.co/api/v1/get-leads ``` ## Request Headers The API request must include the following header: * `Authorization: Bearer ` - The secret key for authenticating the API request. ## Request Body Parameters * `chatbotId` (string, required): The ID of the chatbot for which you want to retrieve leads. * `startDate` (string): Represents the start date of the date range for fetching conversations. The date should be in "Year-Month-Day" format (e.g., 2023-07-10, not 2023-7-10). * `endDate` (string): Represents the end date of the date range for fetching conversations. The date should be in "Year-Month-Day" format (e.g., 2023-07-13, not 2023-7-13). * `page` (string): Specifies the page number of the results for pagination. * `size` (string): Indicates the number of results per page, which is also used for pagination. ## Example Requests ```shell curl --request GET \ --url 'https://www.chatbase.co/api/v1/get-leads?chatbotId=%5BYour%20Chatbot%20ID%5D&startDate=2023-01-01&endDate=2023-12-12&page=1&size=10' \ --header 'accept: application/json' ``` ```javascript const options = {method: 'GET', headers: {accept: 'application/json'}} fetch( 'https://www.chatbase.co/api/v1/get-leads?chatbotId=%5BYour%20Chatbot%20ID%5D&startDate=2023-01-01&endDate=2023-12-12&page=1&size=10', options ) .then((response) => response.json()) .then((response) => console.log(response)) .catch((err) => console.error(err)) ``` ```python import requests url = "https://www.chatbase.co/api/v1/get-leads?chatbotId=%5BYour%20Chatbot%20ID%5D&startDate=2023-01-01&endDate=2023-12-12&page=1&size=10" headers = {"accept": "application/json"} response = requests.get(url, headers=headers) print(response.text) ``` ```json json GET /api/v1/get-leads?chatbotId=%5BYour%20Chatbot%20ID%5D&startDate=2023-01-01&endDate=2023-12-12&page=1&size=10 HTTP/1.1 Accept: application/json Host: www.chatbase.co ``` ## Responses * **200**: Returns an array `collectedCustomers[]` containing conversations that match the provided filters. These conversations represent leads generated by the chatbot. * **400**: If the start/end dates provided are invalid. * **401**: If the API request is unauthorized. * **404**: If the provided chatbot ID is invalid and does not correspond to any existing chatbot. * **500**: If there is an internal server error while processing the request. ### Example Response ```json json { "data": [ { "id": 0, "created_at": "string", "chatbot_owner_user_id": "string", "chatbot_id": "string", "phone": "string", "email": "string", "name": "string" } ] } ``` By making use of the Get Leads API endpoint, you can retrieve and analyze potential leads generated through the chatbot interactions. # null Source: https://chatbase.co/docs/developer-guides/api/message-a-chatbot The Chatbot Interaction API allows you to interact with your chatbots using a `POST` request. This API is available for users subscribed to a paid plan and provides a way to communicate with your chatbot programmatically. ## Endpoint ``` POST https://www.chatbase.co/api/v1/chat ``` ## Request Headers The API request must include the following headers: * `Authorization: Bearer ` - The secret key for authenticating the API request. * `Content-Type: application/json` - The content type of the request payload. ## Request Body The request body should contain the following parameters: * `messages` (array, required): An array containing the ALL the messages between the user and the assistant. Each message object should have `content` and `role` properties. The `content` field represents the text content of the message, and the `role` field can be either "user" or "assistant" to indicate the sender of the message. * `chatbotId`(string, required): Refers to the ID of the chatbot you want to interact with (found on the chatbot settings page). * `stream` (boolean, optional, defaults to false): A boolean value indicating whether to stream back partial progress or wait for the full response. If set to `true`, words will be sent back as data-only server-sent events as they become available, with the stream terminated by a `data: [DONE]` message. If set to `false`, the full response will be returned once it's ready. * `temperature`(number, optional, defaults to 0): What sampling temperature to use, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. * `conversationId` (string, optional): Refers to the ID of the current conversation. The only purpose of this is to save the conversation to the chatbot dashboard. If not provided, the conversation will not be saved. This ID should be generated on your end. You should have different IDs for different conversations and make requests using the same ID for the same conversation. Every time you make a send a message with a specific chatbotId, the last message in the messages array and the response will be added to the conversation. * `model`(string, optional): If this is added to the body, it takes precedence over the model set in the chatbot settings. If not set, the model set in the chatbot settings is used. The option for 'gpt-4 | gpt-4-turbo' only works on the Standard and the Unlimited plans.

* Example: ```json { "messages": [ {"content": "How can I help you?", "role": "assistant"}, {"content": "What is chatbase?", "role": "user"} ], "chatbotId": "", "stream": false, "temperature": 0, "model": "gpt-4o-mini", "conversationId": "" } ``` ## Example Request ```javascript const response = await fetch('https://www.chatbase.co/api/v1/chat', { method: 'POST', headers: { Authorization: 'Bearer ', }, body: JSON.stringify({ messages: [ {content: 'How can I help you?', role: 'assistant'}, {content: 'What is chatbase?', role: 'user'}, ], chatbotId: '', stream: false, model: 'gpt-4o-mini', temperature: 0, }), }) if (!response.ok) { const errorData = await response.json() throw Error(errorData.message) } const data = await response.json() console.log(data) // { "text": "..."} ``` ```python import requests import json url = 'https://www.chatbase.co/api/v1/chat' headers = { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' } data = { "messages": [ {"content": "How can I help you?", "role": "assistant"}, {"content": "What is chatbase?", "role": "user"} ], "chatbotId": "", "stream": False, "temperature": 0 } response = requests.post(url, headers=headers, data=json.dumps(data)) json_data = response.json() if response.status_code == 200: print("response:", json_data['text']) else: print('Error:' + json_data['message']) ``` ```shell curl https://www.chatbase.co/api/v1/chat \ -H 'Authorization: Bearer ' \ -d '{ "messages": [ {"content": "How can I help you?", "role": "assistant"}, {"content": "What is chatbase?", "role": "user"} ], "chatbotId": "", "stream": false, "temperature": 0 }' ``` ```http POST /api/v1/chat HTTP/1.1 Host: www.chatbase.co Authorization: Bearer Content-Type: application/json { "messages": [ {"content": "How can I help you?", "role": "assistant"}, {"content": "What is chatbase?", "role": "user"} ], "chatbotId": "", "stream": false, "temperature": 0 } ``` ## Response The API response will be a JSON object with the following structure: ```json { "text": "Chatbase is an AI chatbot builder that lets you create a GPT-based chatbot that knows data." } ``` ## Example Request with Streaming Functionality If the `stream` parameter is set to `true`, words will be sent back as data-only server-sent events as they become available. To read the stream, you can use the following code snippets: ```javascript const response = await fetch('https://www.chatbase.co/api/v1/chat', { method: 'POST', headers: { Authorization: 'Bearer ', stream: true, temperature: 0, model: 'gpt-4o-mini', }), }) if (!response.ok) { const errorData = await response.json() throw Error(errorData.message) } const data = response.body if (!data) { // error happened } const reader = data.getReader() const decoder = new TextDecoder() let done = false while (!done) { const {value, done: doneReading} = await reader.read() done = doneReading const chunkValue = decoder.decode(value) console.log(chunkValue) // This will log chunks of the chatbot reply until the reply is finished. } ``` ```python import requests import json url = 'https://www.chatbase.co/api/v1/chat' headers = { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' } data = { "messages": [ {"content": "How can I help you?", "role": "assistant"}, {"content": "What is chatbase?", "role": "user"} ], "chatbotId": "", "stream": True, "temperature": 0 } response = requests.post(url, headers=headers, data=json.dumps(data), stream=True) if response.status_code != 200: json_data = response.json() print('Error:' + json_data['message']) else: decoder = response.iter_content(chunk_size=None) for chunk in decoder: chunk_value = chunk.decode('utf-8') print(chunk_value, end='', flush=True) ``` ## Saving Conversations In order to save conversations to the dashboard, a `conversationId` parameter needs to be included in the request body. The full conversation needs to be sent on every API call because Chatbase doesn't save previous messages. The messages received in the latest API call for a given `conversationId` overrides the conversation already saved there. ## Error Handling If there are any errors during the API request, appropriate HTTP status codes will be returned along with error messages in the response body. Make sure to handle these errors gracefully in your application. That's it! You should now be able to message a chatbot using the Message API. # null Source: https://chatbase.co/docs/developer-guides/api/streaming-messages If you are interested in implementing the streaming functionality, the following code can be used to output the response of the Chatbase API in a stream format, giving the appearance of natural, hand typed text. Replace `` and `` before implementation. ```javascript // streamer.js const axios = require('axios') const {Readable} = require('stream') const apiKey = '' const chatId = '' const apiUrl = 'https://www.chatbase.co/api/v1/chat' const messages = [{content: '', role: 'user'}] const authorizationHeader = `Bearer ${apiKey}` async function readChatbotReply() { try { const response = await axios.post( apiUrl, { messages, chatId, stream: true, temperature: 0, }, { headers: { Authorization: authorizationHeader, 'Content-Type': 'application/json', }, responseType: 'stream', } ) const readable = new Readable({ read() {}, }) response.data.on('data', (chunk) => { readable.push(chunk) }) response.data.on('end', () => { readable.push(null) }) const decoder = new TextDecoder() let done = false readable.on('data', (chunk) => { const chunkValue = decoder.decode(chunk) // Process the chunkValue as desired // Here we just output it as in comes in without \n process.stdout.write(chunkValue) }) readable.on('end', () => { done = true }) } catch (error) { console.log('Error:', error.message) } } readChatbotReply() ``` ```python ## streamer.py import requests api_url = 'https://www.chatbase.co/api/v1/chat' api_key = '' chat_id = '' messages = [ { 'content': '', 'role': 'user' } ] authorization_header = f'Bearer {api_key}' def read_chatbot_reply(): try: headers = { 'Authorization': authorization_header, 'Content-Type': 'application/json' } data = { 'messages': messages, 'chatId': chat_id, 'stream': True, 'temperature': 0 } response = requests.post(api_url, json=data, headers=headers, stream=True) response.raise_for_status() decoder = response.iter_content(chunk_size=None) for chunk in decoder: chunk_value = chunk.decode('utf-8') print(chunk_value, end='', flush=True) except requests.exceptions.RequestException as error: print('Error:', error) read_chatbot_reply() ``` # null Source: https://chatbase.co/docs/developer-guides/api/update-a-chatbot The Chatbot Data Update API allows you to update the data for a chatbot by providing the chatbot ID, new name, and source text for text content. This API can be used to replace the existing data of a chatbot with new information. ## Endpoint ``` POST https://www.chatbase.co/api/v1/update-chatbot-data ``` ## Request Headers The API request must include the following header: * `Authorization: Bearer ` - The secret key for authenticating the API request. ## Request Payload The request payload should be sent as a JSON object in the body of the API request. The payload can include the following parameters: * `chatbotId` (required): A unique identifier for the chatbot. It helps to identify the specific chatbot whose data needs to be updated. * `chatbotName` (required): The new name for the chatbot. This parameter allows you to update the name of the chatbot. * `sourceText` (optional): The new source text to update the chatbot. This parameter should contain the new text content that replaces the existing data. The source text should be less than the character limit allowed by your plan. ## Example Request ```javascript const res = await fetch('https://www.chatbase.co/api/v1/update-chatbot-data', { method: 'POST', headers: { Authorization: 'Bearer ', 'Content-Type': 'application/json', }, body: JSON.stringify({ chatbotId: 'example-123', chatbotName: 'new name', sourceText: 'Source text that is less than your plan character limit...', }), }) const data = await res.json() console.log(data) // {chatbotId: 'exampleId-123'} ``` ```python import requests import json url = 'https://www.chatbase.co/api/v1/update-chatbot-data' headers = { 'Authorization': 'Bearer ', 'Content-Type': 'application/json' } data = { 'chatbotId': 'example-123', 'chatbotName': 'new name', 'sourceText': 'Source text that is less than your plan character limit...' } response = requests.post(url, headers=headers, data=json.dumps(data)) data = response.json() print(data) # {'chatbotId': 'exampleId-123'} ``` ```shell curl https://www.chatbase.co/api/v1/update-chatbot-data \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer ' \ -d '{ "chatbotId": "example-123", "chatbotName": "new name", "sourceText": "Source text that is less than your plan character limit..." }' ``` ```http POST /api/v1/update-chatbot-data HTTP/1.1 Host: www.chatbase.co Authorization: Bearer Content-Type: application/json { "chatbotId": "example-123", "chatbotName": "new name", "sourceText": "Source text that is less than your plan character limit..." } ``` ## Response The API response will be a JSON object with the following structure: ```json { "chatbotId": "exampleId-123" } ``` The `chatbotId` field in the response contains the unique identifier assigned to the created chatbot. ## Error Handling If there are any errors during the API request, appropriate HTTP status codes will be returned along with error messages in the response body. Make sure to handle these errors gracefully in your application. That's it! You should now be able to update a chatbot using the Chatbot Update API. # null Source: https://chatbase.co/docs/developer-guides/api/update-chatbot-settings The Update Chatbot Settings API allows you to edit the settings of your chatbot, such as its name, base prompt, initial messages, suggested messages, visibility status, domain restrictions, IP limits, AI model, and more. ## Endpoint ``` POST https://www.chatbase.co/api/v1/update-chatbot-settings ``` ## Request Headers The API request must include the following header: * `Authorization: Bearer ` - The secret key for authenticating the API request. ## Request Body Parameters The request payload should be sent as a JSON object in the body of the API request. The payload can include the following parameters: * `chatbotId` (string, required): Refers to the ID of the chatbot you want to interact with (found on the chatbot settings page). * `name` (string, optional): The new name for the chatbot. * `instructions` (string, optional): The base prompt; instructions for how the chatbot should behave. * `initialMessages` (array of strings, optional): An array of strings containing initial messages to be used by the chatbot. These messages will be what the chatbot greets the user with. * `suggestedMessages` (array of strings, optional): An array of strings containing suggested messages to be used by the chatbot. These messages will appear above the text input in the chatbot interface. * `visibility` (string, optional): The visibility status of the chatbot, which can be set to either 'private' or 'public'. * `onlyAllowOnAddedDomains` (boolean, optional): A boolean flag to enable or disable allowing the chatbot iframe and widget only on specific domains. * `domains` (array of strings, optional): An array of strings containing allowed domains for the chatbot. * `ipLimit` (integer, optional): The limit on the number of messages to be sent from one device every `ipLimitTimeframe` seconds. * `ipLimitTimeframe` (integer, optional): The timeframe (in seconds) in which the messages limit is applied. * `ipLimitMessage` (string, optional): The message to be displayed when the IP limit is exceeded. * `model` (string, optional): The AI model used by the chatbot, which can be set to one of the models mentioned earlier. If not set, the model set in the chatbot settings is used. The option for 'gpt-4' only works on the Standard and the Unlimited plans. * `temp` (number, optional): The temperature parameter for the AI model with a range of \[0, 1]. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. * `collectCustomerInformation` (object, optional): An object containing the information to be collected from the customer. * `title` (string): This field provides a title for the customer contact details section, for example, "Let us know how to contact you." * `name` (object): This sub-object allows you to collect the customer's name. It consists of the following parameters: * `label` (string): A label to describe the name field, helping customers understand what information is being requested. * `active` (boolean): Indicates whether the name field is activated or not. If set to true, the chatbot will prompt the customer to provide their name. * `email` (object): This sub-object facilitates the collection of the customer's email address. It includes the following parameters: * `label` (string): A label that clarifies the purpose of the email field, making it clear to customers what is being asked. * `active` (boolean): Determines whether the email field is active. When set to true, the chatbot will ask the customer for their email. * `phone` (object): This sub-object is intended for gathering the customer's phone number. It incorporates the following parameters: * `label` (string): A label that explains the purpose of the phone number field, helping customers understand the information being sought. * `active` (boolean): Specifies whether the phone number field is in use. When set to true, the chatbot will prompt the customer to provide their phone number. * `styles` (object, optional): An object containing the styling parameters, allowing you to customize the appearance of the chatbot's user interface. * `theme` (string): Choose 'dark' or 'light' for the chatbot interface theme. * `userMessageColor` (string): Define user message color in Hex format * `buttonColor` (string): Set chat bubble button color using Hex format. * `displayName` (string): Display a branded name within the chat interface. * `autoOpenChatWindowAfter` (integer): Automatically open chat window after a defined time (in seconds). * `alignChatButton` (string): Align the chatbot button in the interface, either 'left' or 'right'. ## Example Request Payload ```json { "collectCustomerInformation": { "name": { "label": "Name", "active": true }, "email": { "label": "Email", "active": true }, "title": "Let us know how to contact you" }, "styles": { "theme": "dark", "userMessageColor": "#3B81F7", "buttonColor": "#3B81F7", "displayName": "Product Hunt", "autoOpenChatWindowAfter": 4, "alignChatButton": "left" }, "chatbotId": "[Your ChatbotID]", "name": "my Chatbot", "instructions": "I want you to act as a document that I am having a conversation with. Your name is \"AI Assistant\". You will provide me with answers from the given info. If the answer is not included, say exactly \"Hmm, I am not sure.\" and stop after that. Refuse to answer any question not about the info. Never break character.", "initialMessages": ["Hi! What can I help you with?"], "suggestedMessages": ["Hi! What are you?"], "visibility": "public", "onlyAllowOnAddedDomains": true, "domains": ["example.com"], "ipLimit": 20, "ipLimitTimeframe": 240, "ipLimitMessage": "Too many messages in a row", "model": "gpt-4", "temp": 0 } ``` ## Example Requests ```javascript const options = { method: 'POST', headers: {accept: 'application/json', 'content-type': 'application/json'}, body: JSON.stringify({ collectCustomerInformation: { name: {label: 'Name', active: true}, email: {label: 'Email', active: true}, title: 'Let us know how to contact you', }, styles: { theme: 'dark', userMessageColor: '#3B81F7', buttonColor: '#3B81F7', displayName: 'Product Hunt', autoOpenChatWindowAfter: 4, alignChatButton: 'left', }, chatbotId: '[Your ChatbotID]', name: 'my Chatbot', instructions: 'I want you to act as a document that I am having a conversation with. Your name is "AI Assistant". You will provide me with answers from the given info. If the answer is not included, say exactly "Hmm, I am not sure." and stop after that. Refuse to answer any question not about the info. Never break character.', initialMessages: ['Hi! What can I help you with?'], suggestedMessages: ['Hi! What are you?'], visibility: 'public', onlyAllowOnAddedDomains: true, domains: ['example.com'], ipLimit: 20, ipLimitTimeframe: 240, ipLimitMessage: 'Too many messages in a row', model: 'gpt-4', temp: 0, }), } fetch('https://www.chatbase.co/api/v1/update-chatbot-settings', options) .then((response) => response.json()) .then((response) => console.log(response)) .catch((err) => console.error(err)) ``` ```Text Python import requests url = "https://www.chatbase.co/api/v1/update-chatbot-settings" payload = { "collectCustomerInformation": { "name": { "label": "Name", "active": True } }, "styles": { "theme": "dark", "userMessageColor": "#3B81F7", "buttonColor": "#3B81F7", "displayName": "Product Hunt", "autoOpenChatWindowAfter": 4, "alignChatButton": "left" }, "chatbotId": "[Your ChatbotID]", "name": "my Chatbot", "instructions": "I want you to act as a document that I am having a conversation with. Your name is \"AI Assistant\". You will provide me with answers from the given info. If the answer is not included, say exactly \"Hmm, I am not sure.\" and stop after that. Refuse to answer any question not about the info. Never break character.", "initialMessages": ["Hi! What can I help you with?"], "suggestedMessages": ["Hi! What are you?"], "visibility": "private", "onlyAllowOnAddedDomains": True, "domains": ["example.com"], "ipLimit": 20, "ipLimitTimeframe": 240, "ipLimitMessage": "Too many messages in a row", "model": "gpt-4", "temp": 0.2 } headers = { "accept": "application/json", "content-type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` ```Text Shell curl --request POST \ --url https://www.chatbase.co/api/v1/update-chatbot-settings \ --header 'accept: application/json' \ --header 'content-type: application/json' \ --data ' { "collectCustomerInformation": { "name": { "label": "Name", "active": true } }, "styles": { "theme": "dark", "userMessageColor": "#3B81F7", "buttonColor": "#3B81F7", "displayName": "Product Hunt", "autoOpenChatWindowAfter": 4, "alignChatButton": "left" }, "chatbotId": "[Your ChatbotID]", "name": "my Chatbot", "instructions": "I want you to act as a document that I am having a conversation with. Your name is \"AI Assistant\". You will provide me with answers from the given info. If the answer is not included, say exactly \"Hmm, I am not sure.\" and stop after that. Refuse to answer any question not about the info. Never break character.", "initialMessages": [ "Hi! What can I help you with?" ], "suggestedMessages": [ "Hi! What are you?" ], "visibility": "private", "onlyAllowOnAddedDomains": true, "domains": [ "example.com" ], "ipLimit": 20, "ipLimitTimeframe": 240, "ipLimitMessage": "Too many messages in a row", "model": "gpt-4", "temp": 0.2 } ' ``` ```Text HTTP POST /api/v1/update-chatbot-settings HTTP/1.1 Accept: application/json Content-Type: application/json Host: www.chatbase.co Content-Length: 898 {"collectCustomerInformation":{"name":{"label":"Name","active":true}},"styles":{"theme":"dark","userMessageColor":"#3B81F7","buttonColor":"#3B81F7","displayName":"Product Hunt","autoOpenChatWindowAfter":4,"alignChatButton":"left"},"chatbotId":"[Your ChatbotID]","name":"my Chatbot","instructions":"I want you to act as a document that I am having a conversation with. Your name is \"AI Assistant\". You will provide me with answers from the given info. If the answer is not included, say exactly \"Hmm, I am not sure.\" and stop after that. Refuse to answer any question not about the info. Never break character.","initialMessages":["Hi! What can I help you with?"],"suggestedMessages":["Hi! What are you?"],"visibility":"private","onlyAllowOnAddedDomains":true,"domains":["example.com"],"ipLimit":20,"ipLimitTimeframe":240,"ipLimitMessage":"Too many messages in a row","model":"gpt-4","temp":0.2} ``` ## Responses * **202**: Returns a success message indicating that the chatbot settings have been updated successfully. * **400**: If the request is missing the `chatbotId` parameter. * **401**: If the API request is unauthorized. * **404**: If the `chatbotId` provided is invalid and does not correspond to any existing chatbot. * **500**: If there is an internal server error while processing the request. ## Error Handling If there are any errors during the API request, appropriate HTTP status codes will be returned along with error messages in the response body. Make sure to handle these errors gracefully in your application. That's it! You should now be able to edit your chatbot settings using the Update Chatbot Settings API. # null Source: https://chatbase.co/docs/developer-guides/api/upload-chatbot-icon The Upload Chatbot Icon API endpoint allows you to update the icon of a specific chatbot. ## Endpoint ``` POST https://www.chatbase.co/api/v1/upload-chatbot-icon ``` ## Request Headers The API request must include the following headers: * `Authorization: Bearer ` - The secret key for authenticating the API request. * `Content-Type: multipart/form-data` - The content type for the file upload. ## Request Body The request body should be a multipart form containing the following parameters: * `chatbotId` (string, required): The unique identifier for the chatbot you want to update the icon for (found in the chatbot settings). * `chatbotIconFile` (file, required): The icon file to be uploaded. It must be a square image (length = width) and its size must be under 1MB. ## Example Request ```shell curl --request POST \ --url https://www.chatbase.co/api/v1/upload-chatbot-icon \ --header 'accept: application/json' \ --header 'content-type: multipart/form-data' \ --form 'chatbotId=[Your Chatbot ID]' ``` ```python import requests url = "https://www.chatbase.co/api/v1/upload-chatbot-icon" payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"chatbotId\"\r\n\r\n[Your Chatbot ID]\r\n-----011000010111000001101001--\r\n\r\n" headers = { "accept": "application/json", "content-type": "multipart/form-data; boundary=---011000010111000001101001" } response = requests.post(url, data=payload, headers=headers) print(response.text) ``` ```javascript const form = new FormData() form.append('chatbotId', '[Your Chatbot ID]') const options = {method: 'POST', headers: {accept: 'application/json'}} options.body = form fetch('https://www.chatbase.co/api/v1/upload-chatbot-icon', options) .then((response) => response.json()) .then((response) => console.log(response)) .catch((err) => console.error(err)) ``` ```http POST /api/v1/upload-chatbot-icon HTTP/1.1 Accept: application/json Content-Type: multipart/form-data; boundary=---011000010111000001101001 Host: www.chatbase.co Content-Length: 137 -----011000010111000001101001 Content-Disposition: form-data; name="chatbotId" [Your Chatbot ID] -----011000010111000001101001-- ``` ## Response * **200**: Returns a confirmation message indicating the successful upload and update of the chatbot icon. * **400**: If the chatbot ID is missing. * **401**: If the request is unauthorized. * **404**: If the chatbot ID is invalid. * **500**: If there is an internal server error. ### Example Response ```json { "message": "string" } ``` The Upload Chatbot Icon API endpoint provides a way to update the icon of a chatbot. Upon successful upload and update, a confirmation message is returned in the response. # null Source: https://chatbase.co/docs/developer-guides/api/upload-chatbot-profile-picture # Upload Chatbot Profile Picture API Guide The Upload Chatbot Profile Picture API endpoint allows you to update the profile picture of a specific chatbot. ## Endpoint ``` POST https://www.chatbase.co/api/v1/upload-chatbot-profile-picture ``` ## Request Headers The API request must include the following headers: * `Authorization: Bearer ` - The secret key for authenticating the API request. * `Accept: application/json` - The accepted response content type. * `Content-Type: multipart/form-data` - The content type for the form data. ## Request Body The request body should be a multipart/form-data form containing the following parameters: * `chatbotId` (string, required): The unique identifier for the chatbot you want to update the profile picture for. * `profilePictureFile` (file, required): The profile picture file to be uploaded. The image must be a square (length = width) and its size must be under 1MB. ## Example Request ```shell curl --request POST \ --url https://www.chatbase.co/api/v1/upload-chatbot-profile-picture \ --header 'accept: application/json' \ --header 'content-type: multipart/form-data' ``` ```http POST /api/v1/upload-chatbot-profile-picture HTTP/1.1 Accept: application/json Content-Type: multipart/form-data Host: www.chatbase.co ``` ```javascript const options = { method: 'POST', headers: {accept: 'application/json', 'content-type': 'multipart/form-data'}, } fetch('https://www.chatbase.co/api/v1/upload-chatbot-profile-picture', options) .then((response) => response.json()) .then((response) => console.log(response)) .catch((err) => console.error(err)) ``` ```python import requests url = "https://www.chatbase.co/api/v1/upload-chatbot-profile-picture" headers = { "accept": "application/json", "content-type": "multipart/form-data" } response = requests.post(url, headers=headers) print(response.text) ``` ## Response * **200**: Returns a confirmation message indicating the successful update of the chatbot's profile picture. * **400**: If the chatbot ID is missing. * **401**: If the request is unauthorized. * **404**: If the chatbot ID is invalid. * **500**: If there is an internal server error. The Upload Chatbot Profile Picture API endpoint provides a way to update the profile picture of a chatbot. Upon successful update, a confirmation message is returned in the response. # null Source: https://chatbase.co/docs/developer-guides/api/webhooks # Webhook API Guide The Webhook API guide allows you to set-up webhooks to receive a `POST` request on when an event or more is triggered. ## Payload | Key | Type | Description | | :------------ | :----- | :------------------------------------------------- | | **eventType** | string | [Event type](#event-types) | | **chatbotId** | string | Chatbot ID | | **payload** | Object | Payload of the event. [Learn more](#event-payload) | ## Event types[](#event-types) These are the list of events supported in webhooks: * `leads.submit` : When a customer submit his info (Name, Email, and Phone) to your chatbot. ## Event payload[](#event-payload) The payload of each event: * `leads.submit` : ```json { conversationId: string, customerEmail: string, customerName: string, customerPhone: string } ``` ## Receiving the request You can receive the payload by accessing the body same as any request. But it is recommended to to check the request header `x-chatbase-signature` for securing your endpoint from spam from anyone knows your endpoint. You can achieve this by using SHA-1 (Secure Hash Algorithm 1) function to generate a signature for the request and compare it with `x-chatbase-signature` found in the request headers. If the are identical then the request is from Chatbase. ```javascript Next.js import crypto from 'crypto' import {NextApiRequest, NextApiResponse} from 'next' import getRawBody from 'raw-body' // Raw body is required. export const config = { api: { bodyParser: false, }, } async function webhookHandler(req: NextApiRequest, res: NextApiResponse) { if (req.method === 'POST') { const {SECRET_KEY} = process.env if (typeof SECRET_KEY != 'string') { throw new Error('No secret key found') } const rawBody = await getRawBody(req) const requestBodySignature = sha1(rawBody, SECRET_KEY) if (requestBodySignature !== req.headers['x-chatbase-signature']) { return res.status(400).json({message: "Signature didn't match"}) } const receivedJson = await JSON.parse(rawBody.toString()) console.log('Received:', receivedJson) /* Body example for leads.submit event { eventType: 'leads.submit', chatbotId: 'xxxxxxxx', payload: { conversationId: 'xxxxxxxx', customerEmail: 'example@chatbase.co', customerName: 'Example', customerPhone: '123' } } */ res.status(200).end('OK') } else { res.setHeader('Allow', 'POST') res.status(405).end('Method Not Allowed') } } function sha1(data: Buffer, secret: string): string { return crypto.createHmac('sha1', secret).update(data).digest('hex') } export default webhookHandler ``` ```javascript Node.js import crypto from 'crypto' import {Request, Response} from 'express' // Note: In this example json body parser is enabled in the app export async function webhookHandler(req: Request, res: Response) { if (req.method === 'POST') { const {SECRET_KEY} = process.env if (typeof SECRET_KEY != 'string') { throw new Error('No secret key found') } const receivedJson = req.body const rawBody = Buffer.from(JSON.stringify(receivedJson)) const bodySignature = sha1(rawBody, secretKey) if (requestBodySignature !== req.headers['x-chatbase-signature']) { return res.status(400).json({message: "Signature didn't match"}) } console.log('Received:', receivedJson) /* Body example for leads.submit event { eventType: 'leads.submit', chatbotId: 'xxxxxxxx', payload: { conversationId: 'xxxxxxxx', customerEmail: 'example@chatbase.co', customerName: 'Example', customerPhone: '123' } } */ res.status(200).end('OK') } else { res.setHeader('Allow', 'POST') res.status(405).end('Method Not Allowed') } } function sha1(data: Buffer, secret: string): string { return crypto.createHmac('sha1', secret).update(data).digest('hex') } ``` # Chatbot Event Listeners Source: https://chatbase.co/docs/developer-guides/chatbot-event-listeners ## Overview Chatbase enables developers to track and respond to key events during a chatbot's lifecycle. By using `window.chatbase.addEventListener` and `window.chatbase.removeEventListener`, you can listen for and handle specific events to create interactive and dynamic user experiences. This guide explains how to initialize Chatbase, register event listeners, and handle event payloads. *** ## How to Enable Event Listeners To ensure that the event listeners are available as soon as possible, you need to embed the Chatbase script correctly. **Follow these steps to get the embed code:** 1. Visit the **Chatbase Dashboard**. 2. Navigate to **Connect** > **Embed** > **Embed code with identity**. 3. Copy the embed code and add it to your application. Here’s an example of the embed code you’ll find on the dashboard: ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/developer-guides/images/chatbase-embed-script-example.png) This script ensures the Chatbase SDK is loaded properly, and the `addEventListener` and `removeEventListener` methods are available. *** ## Available Event Types The `eventName` parameter must be one of the following **enum** values: | **Event Name** | **Description** | **Payload** | | ------------------- | --------------------------------------------- | ------------------------------------ | | `tool-call` | Triggered when a tool is called. | `{ name, type, args, toolCallId }` | | `tool-result` | Triggered when a tool returns a result. | `{ name, type, result, toolCallId }` | | `user-message` | Triggered when a user sends a message. | `{ content }` | | `assistant-message` | Triggered when the assistant sends a message. | `{ content }` | *** ## Adding an Event Listener To listen for a specific event, use the following syntax: ```javascript window.chatbase.addEventListener(eventName, callback); ``` ### Parameters * **`eventName`** (enum) — Must be one of the event names listed in [Available Event Types](#available-event-types). * **`callback`** (function) — Function to be called when the event is fired. The event payload is passed as an argument. ### Example Listen for a user message: ```javascript window.chatbase.addEventListener("user-message", (event) => { console.log("User message received:", event.content); }); ``` *** ## Removing an Event Listener To remove a listener for a specific event, use the following syntax: ```javascript window.chatbase.removeEventListener(eventName, callback); ``` ### Parameters * **`eventName`** (enum) — Must be one of the event names listed in [Available Event Types](#available-event-types). * **`callback`** (function) — The exact callback function used when adding the event listener. ### Example Remove a user message listener: ```javascript const userMessageHandler = (event) => { console.log("User message received:", event.content); }; // Attach the event listener window.chatbase.addEventListener("user-message", userMessageHandler); // Remove the event listener window.chatbase.removeEventListener("user-message", userMessageHandler); ``` *** ## Event Payloads Each event type has a specific payload. Below are the details for each event type: * **`tool-call`** ```javascript { name: 'tool-name', type: 'type-of-tool', args: {}, toolCallId: 'unique-id' } ``` * **`tool-result`** ```javascript { name: 'tool-name', type: 'type-of-tool', result: {}, toolCallId: 'unique-id' } ``` * **`user-message`** ```javascript { content: "Hello, chatbot!"; } ``` * **`assistant-message`** ```javascript { content: "Hello, user!"; } ``` *** ## Troubleshooting If you encounter issues, consider the following tips: 1. **Check the event name.** Ensure you’re using a valid event name listed in [Available Event Types](#available-event-types). 2. **Match the callback function.** Ensure the callback reference used in `removeEventListener` matches the one used in `addEventListener`. 3. **Check SDK initialization.** Ensure the Chatbase script has loaded before registering event listeners. *** # Client-Side Custom Actions Source: https://chatbase.co/docs/developer-guides/client-side-custom-actions ## Overview Custom actions can run on both the server, or on the client. It would be beneficial to run a custom action client-side if the chatbot owner wants more flexibility with the action code, or wants to send an API request on behalf of the user, from the client side. *** ## How to Set Up Client-Side Custom Actions 1. **Embed the Chatbot using the new Script:** To ensure that you can register client-side custom actions, you need to embed the Chatbase script correctly. **Follow these steps to get the embed code:** * Visit the **Chatbase Dashboard**. * Navigate to **Connect** > **Embed** > **Embed code with identity**. * Copy the embed code and add it to your application. > **Note:** If you don't need to verify the identity of logged-in users, you can skip the first script in the embed code and only use the chatbot embed script. Here’s an example of the embed code you’ll find on the dashboard: ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/developer-guides/images/chatbase-embed-script-example.png) 2. **Create the Client-Side Custom Action:** To create a client-side custom action: * Visit the **Chatbase Dashboard** * Navigate to **Create custom action** * Fill in the required fields, while choosing the type of the action to be client-side. 3. **Use the SDK `registerTools` method:** Load the Chatbase script and call the `registerTools` method with all the actions and include all the logic that will run when each action is called. The action names must match that written in the custom action page. ### Method Parameters Each custom action method receives two parameters: 1. `args`: Contains all the arguments defined in your custom action configuration 2. `user`: Contains the authenticated user information if [identity verification](/developer-guides/identity-verification) is properly configured ```javascript window.chatbase.registerTools({ get_weather: async (args, user) => { // args contains parameters defined in your custom action // user contains authenticated user data if identity verification is set up try { const response = await fetch( `https://api.weatherapi.com/v1/current.json?q=${args.location}` ); if (!response.ok) { throw new Error("Failed to fetch weather data."); } const data = await response.json(); return { data, status: "success" }; } catch (error) { // Return only the error message without any data return { status: "error", message: error.message }; } }, }); ``` ### Response Format Custom actions should return responses in the following format: #### Success Response When the action is successful, return both the `data` and `status`: ```javascript //data should be either JSON or string // Example with JSON data { data: { temperature: 72, condition: "sunny", humidity: 45 }, status: "success" } // Example with string data { data: "The weather in New York is currently 72°F and sunny", status: "success" } ``` #### Error Response When an error occurs, return only the `status` and error `message`: ```javascript { status: "error", error: "Error message here" } ``` *** ## Important Notes **Multiple Registrations:** Calling `registerTools` multiple times will override previous actions. Make sure to provide all desired actions in a single `registerTools` call. **Environment Limitations:** Client-side custom actions will not work in the Chatbase Playground or Compare features, as these environments don't support client-side code execution. # Control Widget Source: https://chatbase.co/docs/developer-guides/control-widget ## Overview You can dynamically open/close the widget using the `open` and `close` methods. ```javascript window.chatbase.open(); // opens the widget window.chatbase.close(); // closes the widget ``` # Custom Initial Messages Source: https://chatbase.co/docs/developer-guides/custom-initial-messages ## Overview Chatbase allows you to customize the initial messages that your chatbot displays when it first loads. This feature is particularly useful for creating personalized greetings based on user information or setting context-specific welcome messages. *** ## How to Set Up Client-Side Custom Initial Messages 1. **Embed the Chatbot using the new Script:** To ensure that you can set custom initial messages, you need to embed the Chatbase script correctly. **Follow these steps to get the embed code:** * Visit the **Chatbase Dashboard**. * Navigate to **Connect** > **Embed** > **Embed code with identity**. * Copy the embed code and add it to your application. > **Note:** If you don't need to verify the identity of logged-in users, you can skip the first script in the embed code and only use the chatbot embed script. Here’s an example of the embed code you’ll find on the dashboard: ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/developer-guides/images/chatbase-embed-script-example.png) 2. **Use the SDK `setInitialMessages` method:** After the SDK is loaded, you can use the `setInitialMessages` method to define the messages that will be displayed when the chatbot first loads: ```javascript window.chatbase.setInitialMessages(messages); ``` ### Method Parameters * **messages** (array of strings) — An array containing the messages to be displayed in sequence. **Note: The total character count across all messages is limited to 1000 characters. Any content exceeding this limit will be automatically truncated.** ### Example with User Personalization When combined with user identification, you can create personalized greetings: ```javascript // Assuming you have user information const userName = "John Doe"; window.chatbase.setInitialMessages([ `Hi ${userName}!`, "How can I help you today?" ]); ``` *** ## Important Notes * Messages will be displayed in the order they appear in the array * Each message will appear as a separate chat bubble from the assistant * The method can be called at any time to update the initial messages for the next chat session * If called after the chat has already started, the changes will only take effect when the chat is reset or reloaded *** ## Best Practices 1. **Keep messages concise** * Use short, clear messages that help guide the user * Avoid lengthy paragraphs in initial messages 2. **Personalization** * Use user data thoughtfully to create welcoming experiences 3. **Timing** * Set initial messages early in your application's lifecycle * Ideally, set them right after the chatbot loads *** ## Example Implementation Here's a complete example showing how to combine user identification with initial messages: ```javascript // First, identify the user window.chatbase("identify", { user_id: "1234567890", user_hash: "generated_hash", metadata: { name: "John Doe", email: "john@example.com" } }); // Then set personalized initial messages window.chatbase.setInitialMessages([ `Welcome back, ${user.firstName}!`, "I'm here to assist you with any questions about our products.", "What would you like to know?" ]); ``` *** ## Troubleshooting If your initial messages aren't appearing: 1. **Check timing** - Ensure the `setInitialMessages` call happens after the Chatbase script has fully loaded 2. **Verify syntax** - Confirm the input is a valid array of strings 3. **Check for errors** - Monitor your browser's console for any error messages *** # Identity Verification Source: https://chatbase.co/docs/developer-guides/identity-verification ## Overview Chatbase agents can be configured to verify the identity of your users. This is done by hashing the user's id with a secret key generated by Chatbase. The hashed value is then sent to us with custom action requests and is used to verify the user's identity. If the user and the hash do not match, the user id will be removed from all custom action requests. You can also send additional metadata to the chatbot that can be used to personalize the chatbot experience. *** ## Obtaining the User hash * The secret key is generated by Chatbase and is used to hash the user's id. The secret key is available in the Chatbase dashboard under chatbot Connect > Embed > Embed code with identity. * Use the secret key to generate the user hash on the server. ```javascript const crypto = require("crypto"); const secret = "•••••••••"; // Your verification secret key const userId = current_user.id; // A string UUID to identify your user const hash = crypto.createHmac("sha256", secret).update(userId).digest("hex"); ``` * Send the user hash and optional metadata to Chatbase with the identify method. ## How to Enable Identity Verification There are two ways to enable identity verification: 1. **Using the embed code:** Add this **before** the chatbase script. ```javascript ``` Here is an example of what the code should look like: ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/developer-guides/images/chatbase-embed-script-example2.png) 2. **Using the SDK `identify` method:** load the Chatbase script and call the `identify` method with the user's properties and optional metadata. ```javascript window.chatbase("identify", { user_id: "1234567890", user_hash: "1234567890", // this is the hash of the user_id, should be generated on the server user_metadata: { "name": "John Doe", "email": "john@example.com", "company": "Acme Inc", // Add any other relevant user information } }); ``` ## Allowed Properties The `identify` method allows the following properties: | **Property** | **Description** | | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `user_id` | The id of the user, **the only verified variable as it is verified using the user\_hash.** | | `user_hash` | The hash of the user's id. | | `user_metadata` | Optional object containing additional user information. This can include properties like name, email, company, or any other relevant data that you want to make available to your AI agent. **Maximum 1000 characters total for all metadata fields combined. Exceeding this limit will result in the metadata being truncated.** It's strictly used as context to the AI Agent (equivalent to a user message)" | #### Mismatched User ID and User Hash If the user id and user hash do not match, the user id will be removed from all custom actions api requests. #### Calling `identify` multiple times Calling `identify` multiple times will overwrite the previous properties. # Frequently Asked Questions Source: https://chatbase.co/docs/faq/faq Discover answers to common questions about Chatbase, the powerful AI chatbot platform designed for businesses. Chatbase is an AI chatbot builder; it trains LLMs on your data and lets you add a chat widget to your website or chat with it through the API. Just upload a document or add a link to your website and get a chatbot that can answer any question about their content. It allows you to build a custom GPT, embed it on your website, and let it handle customer support, lead generation, engaging with your users, and more. Chatbase supports about 95 languages, and it will try to answer in the language of your question, even if the document is in a different language. Data is safely stored on secure AWS servers. For more information, please visit our [privacy page](https://www.chatbase.co/legal/privacy). You are seeing this message because you've consumed your message credits. You can check the usage page to track your credits consumption. Message credits in Chatbase are used to track the usage of various AI models in interactions with your chatbot. Each message sent by the chatbot consumes a specific number of message credits, depending on the selected AI model. * GPT-4.5 consumes 30 message credits per response. * GPT-4 and Claude 3 Opus consume 20 message credits per response. * GPT-4 Turbo consumes 10 message credits per response. * DeepSeek-R1 consumes 2 message credits per response. * All other models consume 1 message credit per response. You can choose which package suits you depending on your business. Please [**check our pricing**](https://www.chatbase.co/pricing) for more details. Once you attach your document(s) for upload, chatbase will show you the character count of all the attached documents. ### Your message credits are renewed at the start of every calendar month, regardless of when you subscribed. So if you subscribe on the 15th of March, your credits will be renewed on the 1st of April. Yes, you can deploy your chatbot on your custom domain! This feature is included in the Unlimited plan, or you can purchase it as an add-on from the ‘Pricing Plans’ page. This allows you to customize your chatbot’s sharing and embedding URLs by adding your own domain. We're currently working on increasing the character limit, and it will be around 5 times the current one. Stay tuned! # Bubble Source: https://chatbase.co/docs/integrations/bubble ## Step 1: Set Up Your Chatbase Chatbot To integrate your Chatbase AI chatbot into your Bubble application, begin by logging into your Chatbase account. If you haven't already created an account, you can sign up for a free account. After signing in, you can configure your bot within the Chatbase platform by uploading relevant data sources, such as files, text snippets, websites, or question-and-answer pairs, which the bot can use to build its knowledge base. Here is a [step-by-step roadmap for successfully deploying your Chatbase chatbot](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). ## Step 2: Generate and Copy Your Chatbase Chatbot Embed Code 1\. Every chatbot you create on Chatbase has a unique embed code you can use to embed it on your website. Once you've set up your chatbot on Chatbase, navigate to your [**Dashboard**](https://www.chatbase.co/dashboard/) page, and select the specific bot you wish to integrate with your Bubble application.

2\. Clicking on the bot should take you to the bot's playground page. From there, proceed to the **Connect** tab.

3\. Up next, a new page should come up, click on **Copy Script** to copy the code snippet.

## Step 3: Embed Chatbase Chatbot on Your Bubble App 1\. Once you've copied your Chatbase embed code, sign into your Bubble account and head to your account dashboard. 2\. On your dashboard, pick out the Bubble app or website you wish to embed the chatbot on and click the **Launch Editor** button next to it.

3\. Once your Bubble Editor comes up, scroll down to the section of the page you want to add the embed code. 4\. On the left sidebar of the editor, locate the HTML component and drag it to the section of the page.

5\. Double-click on the HTML component to reveal the code editor. 6\. Paste the embed code on the editor and you should automatically see a floating chatbot icon on the bottom left corner of the editing canvas.

7\. You can now preview your Bubble app to test your chatbot.

**Congratulations, your Chatbase chatbot is now live on your Bubble app!** > **Note:** You can customize the appearance and colors of your bot on your Chatbase dashboard. To do this, go to your **dashboard**, choose a bot, click the **Settings** tab on the top of the page, and then click **Chat Interface** on the left sidebar to reveal the chatbot customization options. # Framer Source: https://chatbase.co/docs/integrations/framer ## Step 1: Sign Into Your Chatbase Account and Copy Your Embed Code 1\. Log into your Chatbase account and navigate to the [**Dashboard**](https://www.chatbase.co/dashboard/) page.

2\. On the list of available chatbots, click on the one you want to integrate into your Framer website. 3\. Once you've clicked on your chosen chatbot, you'll be directed to the AI Playground page. 4\. On the page, locate and click on the **Connect** tab at the top of the page.

5\. On the connect tab, click on **Copy Script** to copy the embed code.

## Step 2: Sign Into Your Framer Website and Embed Your Chatbot 1\. Sign in to your Framer website and head to your project dashboard 2\. Click on the website project you wish to embed your Chatbase chatbot

3\. After clicking through to open the website project, locate the page you wish to embed your chatbot on the left side of the editor and click the three-dot icon next to the name of the page.

4\. Click **Settings** to open the settings for that page. 5\. On the Settings page, scroll down to find the section labeled "**Custom Code**." 6\. Right under the Custom Code section, paste your Chatbase chatbot embed code in the first box labeled *"Start of \ tag"* and click **Save** on the top right corner of the panel.

7\. If everything was done well, you should now see a floating Chatbase chatbot icon on the bottom left corner of your Framer website (on the page you added it to)

**Congratulations! Your Chatbase bot is now ready to use on your website.** > **Note:** You can customize the appearance and colors of your bot on your Chatbase dashboard. To do this, go to your [**dashboard**](https://www.chatbase.co/dashboard/), choose a bot, click the **Settings** tab on the top of the page, and then click **Chat Interface** on the left sidebar to reveal the chatbot customization options. # Instagram Source: https://chatbase.co/docs/integrations/instagram Integrating Instagram with Chatbase allows your custom chatbot to communicate directly with customers via your Instagram pages. This integration also enables you to take over the conversation whenever you want and communicate with users yourself through Instagram's direct messaging. It provides a seamless and efficient way to handle inquiries and automate responses, while giving you the freedom to interact with your customers whenever you choose. This guide will walk you through the necessary steps to connect your chatbot to Instagram, ensuring smooth and effective customer interactions. ## Perquisites You will need the following: * An Instagram [Professional Account](https://www.facebook.com/help/instagram/138925576505882). * A Facebook Page connected to that account. ## Connecting Instagram 1\. First navigate to the instagram page settings for you Professional Account, then under '**How others can interact with you**', click on **Messages and story replies** > **Message controls** > **Allow Access to Messages** 2\. Navigate to your dashboard, and pick a chatbot.

3\. Navigate to **Connect** > **Integrations**.

4\. Click on **Connect** then **I understand**.

5\. Click on **Continue.**

6\. Login on **Get Started**. This will allow you to login to instagram and turn your account to a Professional Account if it is not already.

7\. Login to instagram.

8\. Choose the businesses affiliated with you Instagram page. If you have no business select **Opt in all current future businesses.**

9\. Choose the Facebook Page(s) linked to your Instagram.

10\. Select the Instagram page(s) you want to integrate.

11\. Click save.

12\. Your pages should be integrated successfully to see the pages integrated click on **Manage.**

13\. You can add more pages or delete existing ones from the manage page.

## The Human Takeover Feature The human takeover feature allows you to takeover the chat whenever you would like and chat with users yourself! It works on a conversation level meaning you would be able to choose a specific conversation from the dashboard and stop the chatbot from answering that conversation. > **Note:** some conversations may not have the human takeover icon, that happens when you delete a page from the integrations dashboard, you would still have access to your conversations in the chat logs, but since the integration was deleted you will not have access to the takeover feature since this page's integration was deleted. This will also happen if you delete a page and add it again, so be careful when deleting pages from the Instagram dashboard. #### to enable human takeover for a specific conversation: 1\. Navigate to Activity either through the Navbar or through the messenger dashboard. 2\. in the **Chat logs section** make sure to show only Instagram chats.

3\. Click the human takeover icon.

5\. You can click the icon again to restore access to the chatbot. ## Connecting different chatbots to different pages With the Chatbase Instagram integration, you can connect different chatbots to various pages. This capability allows multiple chatbots to manage different Instagram pages, providing specialized interactions for each page. here are the steps to adding different chatbots to different pages. 1\. After connecting the first page(s) you should now have access to the **manage Instagram pages** integrations page. navigate to the chatbot you want to connect then **Activity > Integrations > manage.** 2\. Click the **Manage** button to navigate to the dashboard. If you want to connect another chatbot to an already connected page, click, then delete the page. 3\. Navigate to the chatbot you want to integrate to the page deleted, then reinitialize the integrations steps. > **Note:** if you deleted a chatbot it will be selected in the integration steps, don't deselect any chatbot you want to stay connected to the instagram or facebook integrations on chatbase as deselecting the chatbot will result in disabling that chatbot for chatbase. Now this brings an end to the Messenger integration guide, for any further questions please do not hesitate to [contact us](https://www.chatbase.co/help). # Messenger Source: https://chatbase.co/docs/integrations/messenger Integrating Messenger with Chatbase allows your custom chatbot to communicate directly with customers via your Facebook pages. It also allows you to takeover the conversation whenever you want and communicate with users yourself through messenger. This provides a seamless and efficient way to handle inquiries and automate responses, while giving you the freedom to talk to your customers whenever you want. This guide will walk you through the necessary steps to connect your chatbot to Messenger for your facebook pages, ensuring smooth and effective customer interactions. ## Connecting to messenger 1\. First navigate to your dashboard, and pick a chatbot.

2\. Navigate to **connect** > **Integrations**

3\. Click on Connect if it is the first time you use the integration or manage, if you already connected pages before.

4\. If this is the first time you will be asked for permission to allow chatbase to use your information. **Note:** if you integrated some pages and would like to modify your selection pick the **Edit Previous Settings** option.

5\. Choose which pages you would like to integrate the chatbot with by selecting the **Opt into current pages only** option, if you want to integrate all pages on your account select the **Opt all current pages** option.

6\. Review the permissions and click save.

7\. click on **done** and wait for the integration to connect, this should take only a few seconds.

8\. Once connected you can manage you pages through the Messenger dashboard. It allows you to add new pages by clicking the **Connect a new Facebook page** button or delete existing pages using the three dots next to the page.

## The Human Takeover Feature The human takeover feature allows you to takeover the chat whenever you would like and chat with users yourself! It works on a conversation level meaning you would be able to choose a specific conversation from the dashboard and stop the chatbot from answering that conversation. > **Note:** some conversations may not have the human takeover icon, that happens when you delete a page from the integrations dashboard, you would still have access to your conversations in the chat logs, but since the integration was deleted you will not have access to the takeover feature since this page's integration was deleted. This will also happen if you delete a page and add it again, so be careful when deleting pages from the messenger dashboard. #### to enable human takeover for a specific conversation: 1\. Navigate to Activity either through the Navbar or through the messenger dashboard. 2\. in the **Chat logs section** make sure to show only messenger chats.

3\. Click the human **takeover icon** to the right of source.

4\. Click the icon to enable human takeover.

5\. You can click the icon again to restore access to the chatbot. ## Connecting different chatbots to different pages With the Chatbase Messenger integration, you can connect different chatbots to various pages. This capability allows multiple chatbots to manage different Facebook pages, providing specialized interactions for each page. here are the steps to adding different chatbots to different pages. 1\. After connecting the first page(s) you should now have access to the **manage Facebook pages** integrations page. navigate to the chatbot you want to connect then **Activity > Integrations > manage.**

2\. Click the **Manage** button to navigate to the dashboard. As shown in the **chatbot field**, all my pages are connected to the same chatbot. If I want to connect another chatbot to an already connected page, click, then simply delete the chatbot.

3\. Click **connect a new Facebook Page**, and make sure you are on the correct chatbot. Then click **edit previous settings.**

4\. A list of pages connected will be displayed, if you deleted a chatbot in **step 2** it will be selected here, don't deselect any chatbot you want to stay connected to chatbase as deselecting the chatbot will result in disabling that chatbot for chatbase.

5\. Select the page you want to add the new chatbot to, and click the next button. if the page was already selected click the next button.

6\. Click the save button.

7\. As shown the new page was added to the dashboard, and is now integrated with the new chatbot.

Now this brings an end to the Messenger integration guide, for any further questions please do not hesitate to [contact us](https://www.chatbase.co/help). # Shopify Source: https://chatbase.co/docs/integrations/shopify ## Step 1: Sign Into Chatbase and Configure Your Chatbase Chatbot To add a Chatbase chatbot to your Shopify website, sign into your Chatbase account to create and set up a chatbot. If you don't have a Chatbase account, you can start by creating one for free. If you are not sure how to create a chatbot, here is a [detailed guide on how to create a chatbot on Chatbase](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). ## Step 2: Generate and Copy the Chatbot Embed Code To embed your chatbot on your Shopify site, you'll need to first generate an embed code for your chatbot. To do this: 1\. Head over to your [**Dashboard**](https://www.chatbase.co/dashboard/) page and click on the bot you want to embed on your Shopify website to reveal the bot's Playground page.

2\. On the playground page, click on **Connect** at the top of the page.

3\. Up next, click on **Copy Iframe** to copy the chatbot embed code.

## Step 3: Sign Into Your Shopify Website and Embed Your Chatbot To add the embed code to your Shopify website: 1\. Log into your Shopify account and head to your Shopify admin page. 2\. On the left sidebar of the admin page, click on **Online Store** and then click on **Pages** to reveal the list of pages on your store website. 3\. Click on the page you wish to embed the chatbot. (For this example, we want to embed it in the Contact page)

4\. The page you click on should open on an HTML editor, click the source code icon on the top right corner of the editor.

5\. Paste the embed code on the code editor and click **Save** on the top right corner of the page.

6\. Click the source code icon again to return to the visual editor. A preview of your Chatbase chatbot should be loaded in the editor.

Your Chatbase chatbot has now been added to your Shopify website. You can optionally click the **View page** button on the top right corner of the page editor to see how your chatbot will look on your live page. > **Note:** You can customize the appearance and colors of your bot on your Chatbase dashboard. To do this, go to your **dashboard**, choose a bot, click the **Settings** tab on the top of the page, and then click **Chat Interface** on the left sidebar to reveal the chatbot customization options. # Slack Source: https://chatbase.co/docs/integrations/slack Chatbase provides a quick and easy way to add an intelligent AI-powered chatbot to your Slack workspace. Integrating Chatbase into Slack enables your team to instantly leverage a wealth of AI capabilities right within your Slack workspace. In just a few minutes, you can make a Chatbase chatbot available across your company’s Slack channels to improve communication, boost productivity, and enhance the employee experience. The chatbot will be able to understand natural language and respond to common queries, resolve issues, look up information, and supercharge your Slack with round-the-clock automated support Here’s how to integrate a Chatbase chatbot into your Slack workspace: ## Step 1: Access and Configure Your Chatbase Chatbot These steps assume that you have already created a Chatbase account and that you have a Chatbase chatbot already available for use. If you haven't yet, [create a free Chatbase account](https://www.chatbase.co/auth/signup) and build your first AI chatbot. For example, you can create a company FAQ chatbot to handle common employee questions or build a recruiting assistant to screen candidates and schedule interviews. Get your chatbot ready before moving to the integration. **Read More:** [A step-by-step guide to creating a Chatbase chatbot in just a few minutes](https://www.chatbase.co/blog/how-to-create-your-own-chatbot-without-coding). ## Step 2: Locate the Slack Integration 1\. Once you have a Chatbase account and a chatbot set up, head over to your [dashboard](https://www.chatbase.co/dashboard/). On your dashboard, you’ll find a list of all the chatbots you have created. Locate and click on the chatbot you wish to integrate with Slack.

2\. After clicking on a chatbot, the chatbot preview page should come up, click on **Connect** at the top of the page and then the **Integrations** tab on the left side of the page. This will take you to a page with a list of integration options. 3\. Click on **Connect** under the Slack card

4\. Up next, you’ll be asked to authorize Chatbase to access your Slack account and workspace.

5\. Scroll down and click on **Allow**.

5\. If all goes well, you should get a message saying “**Chatbase has been successfully added to your workspace.**”

6\. Click on **Open Slack** to launch your Slack workspace. 7\. You’ll be prompted to sign into your Slack workspace or select from a list of Slack workspaces you are currently signed into. Click open beside the target workspace.

## Step 3: Deploy Slack Bot Once you’ve launched the Slack workspace that hosts your Chatbase chatbot, you can start setting up the chatbot as a Slack bot. To do this: 1\. Open any channel on your Slack workspace, and type **@chatbase** followed by any question related to the purpose of your chatbot. This should trigger a prompt by Slack asking you to invite the chatbot to the channel or take no action.

2\. Click on **Invite Them**. The chatbot will then be available in the channel to answer any questions you might have. ## Step 4: Start Chatting! That's it! Your Chatbase chatbot is now integrated and ready to elevate team communication in your Slack workspace. Anytime you or any member of your team needs a question answered, just type @chatbase followed by your question, and your chatbot will respond.

Team members can direct questions to your intelligent bot in any channel or DM that has the bot. The chatbot provides helpful responses powered by conversational AI, giving your team access to an advanced virtual assistant 24/7. Integrating Chatbase into Slack unlocks game-changing possibilities. Your employees gain a productivity-boosting bot that enriches the collaboration experience. So go ahead, and give your new AI-powered team member a try! Intelligent automation is just a chat away. # Stripe Source: https://chatbase.co/docs/integrations/stripe Integrating Stripe with Chatbase allows your custom chatbot to access and display key billing information directly to users, enhancing customer support and transparency. With this integration, your chatbot can securely retrieve and show users their subscriptions and invoice history, streamlining common billing inquiries. This setup provides a fast, automated way to manage subscription details, while giving users a clear view of their payment status and history—all within the chat experience. This guide will walk you through the steps to connect Stripe to your Chatbase chatbot, enabling smooth and secure access to subscription and invoice data. ## Step 1: Access and Configure Your Chatbase Chatbot These steps assume that you have already created a Chatbase account and that you have a Chatbase chatbot already available for use. If you haven't yet, [create a free Chatbase account](https://www.chatbase.co/auth/signup) and build your first AI chatbot. For example, you can create a company FAQ chatbot to handle common employee questions or build a recruiting assistant to screen candidates and schedule interviews. Get your chatbot ready before moving to the integration. **Read More:** [A step-by-step guide to creating a Chatbase chatbot in just a few minutes](https://www.chatbase.co/blog/how-to-create-your-own-chatbot-without-coding). ## Step 2: Locate the Stripe Integration 1\. Once you have a Chatbase account and a chatbot set up, head over to your [dashboard](https://www.chatbase.co/dashboard/). On your dashboard, you’ll find a list of all the chatbots you have created. Locate and click on the chatbot you wish to integrate with Stripe.

2\. After clicking on a chatbot, the chatbot preview page should come up, click on **Actions** at the top of the page and then the **Integrations** tab on the left side of the page. This will take you to a page with a list of integration options. 3\. Click on **Connect** under the Stripe card

4\. Up next, you’ll be asked to authorize Chatbase to access your Stripe account.

5\. After clicking on **Continue** you will be asked to choose the account you want to connect to.

5\. If all goes well, you should be redirected back to Chatbase with a message saying “**Stripe integration successful.**”

6\. Add Stripe accounts to your customers' contacts. For more information, see [Contacts](/developer-guides/api/contacts/contact). ## Step 3: Start Chatting! That's it! Your Chatbase chatbot is now integrated and ready to provide superb customer support. # Sunshine Source: https://chatbase.co/docs/integrations/sunshine As part of Zendesk, Sunshine Conversations serves as a live chat solution. This integration centralizes communication, enabling support teams to efficiently track and resolve customer inquiries, ultimately improving response times and customer satisfaction. Chatbase offers an integration with Sunshine Conversations in order to give the chatbot the ability to connect the user to a live chat agent for fixing problems that require human interaction with the user. > **Note** This requires your Zendesk Account to have a minimum Suite plan of **Professional** or above ## Step 1: Sign Into Your Zendesk Account 1. Sign in to your Zendesk Account as an Admin and navigate to the **Admin Center** 2. Navigate to **Apps and integrations** > **APIs** > **Conversations API** 3. Click on **Create API Key**, enter **Chatbase** as the name and press **Next** 4. Copy the **App ID**, **Key ID** and **Secret key** displayed

## Step 2: Set up the Sunshine Integration 1\. Go to the [dashboard](https://www.chatbase.co/dashboard/) of your Chatbase account. 2\. You should see a list of chatbots, click the chatbot you wish to enable live chat for. You should be taken to the chatbot's preview page.

3\. Navigate to **Actions** > **Integrations**. Click **Connect** on the Sunshine Integration card.

4\. Enter the copied **App ID**, **Key ID** and **Secret key**, and press **Submit**. ## Step 3: Enable Multi-Conversations Option in Zendesk We need to enable the multi-conversations option in Zendesk to allow for the same user to open multiple tickets, one per conversation, at the same time. Since the same user can have multiple conversations opened at the same time, then this option must be enabled for a smooth experience. 1\. Sign in to your Zendesk Account as an Admin and navigate to the **Admin Center** 2\. Click **Channels** in the sidebar, then select **Messaging and social** > **Messaging**. 3\. At the top of the page, click **Manage settings**. 4\. Under Web Widget and Mobile SDKs, expand **Multi-conversations**. 5\. Click **Set up multi-conversations**. 6\. Click **Turn on multi-conversations for your account**, then select the channels on which you want to offer multi-conversations, then click **Save**. For more information regarding multi-conversations for messaging, visit [Understanding multi-conversations for messaging](https://support.zendesk.com/hc/en-us/articles/8195486407706-Understanding-multi-conversations-for-messaging). ## Step 4: Enable End Messaging Sessions in Zendesk To allow agents to end conversations when issues are resolved, you'll need to enable the messaging session end feature in Zendesk. 1\. Sign in to your Zendesk Account as an Admin and navigate to the **Admin Center** 2\. Click **Channels** in the sidebar, then select **Messaging and social** > **Messaging**. 3\. At the top of the page, click **Manage settings**. 4\. Under Advanced, expand **Ending sessions**. 5\. Select **Agents can end messaging sessions at any time**. 6\. Click **Save settings**. For more information regarding ending messaging sessions, visit [About ending messaging sessions](https://support.zendesk.com/hc/en-us/articles/8009788438042-About-ending-messaging-sessions). ## Step 5: Enable the Live Chat Action 1\. Go to the [dashboard](https://www.chatbase.co/dashboard/) of your Chatbase account. 2\. Choose the chatbot you have integrated with Sunshine Conversations. 3\. Navigate to **Actions**. 4\. Click on **Create Action** under the Sunshine Live Chat card. 5\. Customize the **When to use**, then save and enable the action. # Webflow Source: https://chatbase.co/docs/integrations/webflow ## Step 1: Sign Into Your Chatbase Account and Set Up Your Chatbot 1. Sign up for a free Chatbase account if you don't already have one. 2. Log into your Chatbase account and navigate to the bot creation page. 3. Provide training data for your new bot by uploading sources like text snippets, documents, website content, or Q\&A pairs. 4. Train and test your bot in Chatbase until it responds accurately to queries. Not familiar with creating a Chatbase chatbot? Here is a [step-by-step guide to building a chatbot with Chatbase](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). ## Step 2: Copy Your Chatbot Embed Code Once you’ve set up and tested your Chatbase bot, you’ll need the embed code to display the bot widget on your website. To do this: 1\. Go to the [dashboard](https://www.chatbase.co/dashboard/) of your Chatbase account. 2\. You should see a list of chatbots, click the chatbot you wish to integrate into your Webflow website. You should be taken to the chatbot's preview page.

3\. On the chatbot preview page, click on the **Connect** tab.

4\. A new page should come up. Click on **Copy Iframe** to copy the provided HTML code.

## Step 3: Set Up a Container to Display Your Chatbot Widget Before adding the embed code to your Webflow site, you will need to create a container to display the widget. This will ensure that the widget is displayed in the correct place on your website and doesn't extend the entire width of the page. 1\. To create a container, on Webflow, log into your Webflow account and go to your dashboard. 2\. On your Webflow dashboard, you’ll find a list of all your website projects, hover on the website you want to add the chatbot to and click on **Open Designer**.

3\. On the designer page, click on the file icon (**Pages**) on the top left corner of the webflow site designer and select the page you want to embed the chatbot.

4\. Once you’ve selected the page, click the Plus button (**Add elements**) on the top left corner of the designer screen, and a list of available elements should come up. 5\. Drag the **Section** element to the portion of the page you want to embed your chatbot. 6\. Drag a **Container** element unto the **Section.** 7\. Drag a **Div** element unto the Container element and set the size of the Div element to ensure that the bot will be contained within the Div and does not span the entire width of the page.

8\. Now, scroll down down the list of elements and drag the **Embed** element unto the Div you added on the Webflow canvas.

9\. Select and double-click the Embed element to reveal the HTML Embed code editor. 10\. Paste the Chatbase chatbot embed code from Step 2 above and click **Save & Close**.

If all goes well, you should see a preview of the chatbot on the live preview of your Webflow website right inside the designer.

After completing these steps, your chatbot should be ready to serve your website visitors! If you are having difficulties with managing the dimension of your Embed and chatbot element, it is a common problem. Webflow components take a bit of getting used to. You can follow this [official Webflow documentation on the Embed element](https://university.webflow.com/lesson/custom-code-embed?topics=elements) to learn more about embedding a third-party tool like Chatbase chatbot on a Webflow website. > **Note:** You can customize the appearance and colors of your bot on your Chatbase dashboard. To do this, go to your **dashboard**, choose a bot, click the **Settings** tab on the top of the page, and then click **Chat Interface** on the left sidebar to reveal the chatbot customization options. # Weebly Source: https://chatbase.co/docs/integrations/weebly ## Step 1: Sign Into Your Chatbase Account and Set up your Bot To embed your Chatbase bot into your Weebly website, first sign in to your Chatbase account. If you don't have an account yet, you can create one for free. Once signed in, you can set up your bot in Chatbase by uploading data sources like files, text snippets, websites, or Q\&A pairs that the bot can learn from. Here is a [step-by-step guide for setting up your Chatbase chatbot](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). ## Step 2: Generate and Copy Chatbot Embed Code 1\. After setting up your chatbot, head to your [dashboard](https://www.chatbase.co/dashboard/), and click on the bot you want to embed on your Weebly website to reveal the bot's Playground page.

2\. On the chatbot Playground page, click on the **Connect** tab at the top of the page.

3\. Click on **Copy Iframe** to copy the HTML code.

## Step 3: Add Embed Code to Your Weebly Website To add a Chatbase chatbot to your Weebly website: 1\. Sign in to your Weebly account and head to the **Edit site** page. 2\. Select the page to edit. 3\. From the Basic toolbar on the left side of the editing page, locate the widget that says **Embed Code**.

4\. Drag the **Embed Code** element to wherever you want your chatbot to appear on the page.

5\. You should then see a text element that says **Click to set custom HTML** where the Embed code widget was placed. Click on the text, and then click on **Edit Custom HTML.** 6\. Paste your Chatbase embed code into the custom HTML box.

7\. Click outside the element and your chatbot should appear on the page.

Congratulations, your chatbot is now live on your Weebly website! > **Note:** You can customize the appearance and colors of your bot on your Chatbase dashboard. To do this, go to your **dashboard**, choose a bot, click the **Settings** tab on the top of the page, and then click **Chat Interface** on the left sidebar to reveal the chatbot customization options. # WhatsApp Source: https://chatbase.co/docs/integrations/whatsapp Integrating WhatsApp with Chatbase allows your custom chatbot to communicate directly with customers via WhatsApp, providing a seamless and efficient way to handle inquiries and automate responses. This guide will walk you through the necessary steps to connect your chatbot to a WhatsApp phone number, ensuring smooth and effective customer interactions. ## Before we start * The WhatsApp phone number integrated with the chatbot can only be used by the chatbot, and can't be used on WhatsApp or WhatsApp business. If you already use the phone number with WhatsApp, you must delete your account in the app first. * To delete WhatsApp * Navigate to WhatsApp or WhatsApp Business app. * Navigate to **Settings > Account.** * Select **Delete my account.** This may take a few minutes, but after that, the number will be available to use. * If you previously used WhatsApp through Meta Developer for business you must disable **two-step verification** * Navigate to you [**Whatsapp Business Account**](https://business.facebook.com/wa/manage/home/) and login. * Choose the phone number you would like to integrate. * Navigate to **Settings > Two-step verification** and choose turn off two-step verification. 1\. Navigate to the Chatbot you would like to integrate with WhatsApp.

2\. Navigate to Dashboard > \[Chatbot] > Connect > Integrations. 3\. Click Connect on the WhatsApp integration card.

4\. Log in with your personal Facebook Account.

5\. Click **Get started**

6\. Choose or create a business profile.

7\. Create a WhatsApp business profile or select an existing one.

8\. Fill in the information for the Business profile.

9\. Add a phone number, , it is recommended to have only one associate number in this profile.

10\. Click **Continue**.

11\. Wait a few seconds for information verification.

12\. Click on **Finish**.

13\. (Optional) You can modify your WhatsApp bot styling or delete your phone number by clicking the "I" icon next to WhatsApp or by navigating to the manage WhatsApp page .

14\. (Optional) Navigate to **Profile** and update your WhatsApp settings then click the **Save** button.

Now that your integration is active you can send 1000 free messages monthly. Make sure to add a payment method on your [Meta billing settings](https://business.facebook.com/billing_hub) to be able to send more than 1000 messages per month. Congratulations! You finished integrating your Chatbase chatbot to WhatsApp, your chatbot is now ready to reply to all the messages received through your WhatsApp! # Wix Source: https://chatbase.co/docs/integrations/wix ## Step 1: Set Up Your Chatbase Chatbot To begin the integration process, you'll need to sign into your Chatbase account. If you haven't created an account yet, [sign up for a free account](https://www.chatbase.co/auth/signup). Once logged in, proceed to set up your chatbot by uploading relevant data sources. These data sources can include files, text snippets, websites, or question-and-answer pairs, which will form the knowledge base for your chatbot. If you need help with setting up a functional Chatbase chatbot, here is a [step-by-step guide for setting up and deploying your Chatbase chatbot](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). ## Step 2: Generate and Copy the Chatbase Chatbot Embed Code 1\. After configuring your chatbot, navigate to your [**dashboard**](https://www.chatbase.co/dashboard/) page and select the specific bot you wish to embed. Clicking on the chosen bot should take you to the bot's preview page.

2\. On the chatbot preview page, locate and click on the **Connect** tab.

3\. Next, a new page will appear displaying the HTML code snippet for embedding your chatbot. Copy this code by clicking the "**Copy Script**" button.

With the embed code in hand, you are now ready to proceed with the integration process within your Wix application. ## Step 3: Sign Into Your Wix Account and Embed Your Chatbot 1\. Sign in to your Wix website and head to your dashboard. 2\. On your dashboard, locate and click on **Design Site** in the top right corner of the page.

3\. Your site should load your site on the Wix website editor. 4\. Scroll down to any section of the website you wish to add the Chatbase chatbot. 5\. Click the big plus (**Add Elements**) button on the left sidebar of the Wix site editor.

6\. Scroll down to locate and click on **Embed Code**, followed by **Popular Embeds** and then **Custom Code**.

7\. The custom code widget should pop up, click **+ Add Custom Code** in the top right 8\. Paste the code snippet into the custom code editor. 9\. Provide a name for your code. 10\. Choose an option under **Add Code to Pages**. 11\. Choose where to place your code under Place Code in 12\. Click Apply. Once you've applied the changes, preview your website and you should see the floating Chatbase chat icon on your website.

**Congratulations, your Chatbase chatbot is now live on your Wix website.** > **Note:** You can customize the appearance and colors of your bot on your Chatbase dashboard. To do this, go to your **dashboard**, choose a bot, click the **Settings** tab on the top of the page, and then click **Chat Interface** on the left sidebar to reveal the chatbot customization options. # WordPress Source: https://chatbase.co/docs/integrations/wordpress ## **Step 1: Sign Into Chatbase and Configure Your Chatbase Chatbot** To add a Chatbase chatbot to your WordPress website, you'll need to first sign into your Chatbase account to create and set up a chatbot. If you don't have an account, you can start by [creating a Chatbase account for free](https://www.chatbase.co/auth/signup). If you are not sure how to create a chatbot, read this [detailed guide on how to create a chatbot on Chatbase](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). ## Step 2: **Install Chatbase on Your WordPress Website** **1. Log in to your WordPress admin dashboard:** Your dashboard URL is typically *yourdomainname.com/wp-admin/*. You can also access it through your web hosting control panel. **2. Install and activate the Chatbase plugin:** * In the left sidebar of your WordPress admin dashboard, click on **Plugins**.

* Click **Add New Plugin** at the top of the next page.

* In the search bar on the next page, type "**Chatbase**" to search for the Chatbase plugin. * Find the Chatbase WordPress plugin, click **Install Now**, then **Activate**.

**3. Add your Chatbot ID:** 1. In the left sidebar of the WordPress Admin dashboard, click **Settings**. 2. Look for **Chatbase options** and click on it. 3. In the Chatbase settings, find the text box labeled "Chatbot ID".

**4. Copy and paste your Chatbot ID:** * Go to your Chatbase account and navigate to your Dashboard. * Select the chatbot you want to embed. * Click on the chatbot, then click on the "**Settings**" tab. At the top of the settings page, you'll find the Chatbot ID. Copy it. * Paste the copied Chatbot ID into the text box in your WordPress settings.

**5. Save your changes:** Click **Save Changes**. Your Chatbase chatbot should now be live on your WordPress website!

# Zapier Source: https://chatbase.co/docs/integrations/zapier ## Step 1: Sign Into Your Chatbase Account and Set Up Your Chatbot 1\. Sign up for a free Chatbase account. 2\. Log in and go to the bot creation page. 3\. Upload training data like text, documents, websites or Q\&A pairs. 4\. Train and test your bot until its responses meet your requirements. Not familiar with creating a Chatbase chatbot? Here is a [step-by-step guide to building a chatbot with Chatbase](https://www.chatbase.co/blog/step-by-step-guide-to-build-ai-chatbot). You can automate a lot of things with Chatbase and Zapier, it all boils down to what you want to achieve and your creativity. Here are some of the things you can do when you integrate your Chatbase bot with Zapier: **1. Draft responses to customer emails** * Send new customer emails from your inbox to Chatbase. * Using your company's documentation, Chatbase can draft a relevant response. * Automatically save the AI-generated response as a draft in your email client or send it directly. **2. Categorize and prioritize incoming support emails** * Connect Chatbase with your email client (e.g., Gmail, Outlook). * Chatbase can analyze the tone and content of incoming emails. * Categorize emails as urgent, non-urgent, or by specific topics. * Add notes or tasks to your project management tool or spreadsheet for follow-up. **3. Add AI-generated instructions or solutions to support tickets** * Integrate Chatbase with tools like Jira, Intercom, or Zendesk * When a new support ticket is created, send the details to Chatbase * Chatbase can analyze the issue using your documentation and suggest initial solutions or step-by-step instructions * Automatically add the AI-generated response or context to the support ticket **4. Analyze customer feedback forms** * Integrate Chatbase with form tools like Typeform or Google Forms * Chatbase can analyze the feedback for intent, tone, and sentiment * Generate summaries or insights from the feedback * Send the analysis to your support team via email, Slack, or a spreadsheet There's so much you can achieve with a combination of the two apps. For this guide, we'll work you through how to set up Chatbase to collect leads and add the leads to a Google Docs file using Zapier. ## Step 2: Set Up Chatbase to Collect Leads 1\. Sign in to your Chatbase account and head to your account dashboard. 2\. Click on the chatbot you want to set up lead collection for .

3\. Clicking on the bot should bring up the bot preview page. On the page, click on the **Setting** tab at the top of the page, and then **Leads** on the left sidebar of the page.

4\. Toggle on the switch beside each lead form field. 5\. Click **Save** on the bottom right corner of the page to apply the changes.

Once lead collection has been set up on the Chatbase end, you can now connect the chatbot to Zapier. ## **Step 3: Connect Chatbase to Zapier** This step assumes that you have an active Zapier account. Remember, the idea is to set up set up the Zapier account to receive leads from from Chatbase chatbot, process it and add it to a Google docs file. To do this: #### **Step 1: Set Up a Trigger** 1\. Sign in to your Zapier account. 2\. Click on **Create** and then **Zaps** on the top left corner of the Zapier app homepage.

3\. On the Zap editor click on **Trigger**.

4\. On the pop-up menu, search for Chatbase on the search bar and click on it.

5\. Next, on the right side of the page, click on the form field labeled **Event** and select **Form Submission**. 6\. Click on **Continue.**

7\. To use your Chatbase account on Zapier, you'll need to give Zapier access to your Chatbase account. To do this, click on **Sign in** on the next page after you click **Continue**.

8\. An authentication page should come up, provide your Chatbase API key (and optionally a display name) and then click **Yes, Continue to Chatbase** to link your Chatbase account.

***Note**: To get your API keys, head to your* [*account dashboard*](https://www.chatbase.co/dashboard/) *and click on the **Settings** tab at the top of the page. Click on **API keys** on the left sidebar and then copy out your API keys if you have one or click on Create API Key to create a new one.*

9\. Up next, click on **Continue** on the screen that comes up after authenticating your Chatbase account. 10\. On the next screen, you will be asked to provide your chatbot ID. Paste your chatbot ID in the provided input field and click **Continue**. ***Note**: To find your chatbot ID, head over to your* [*dashboard*](https://www.chatbase.co/dashboard/)*, click on any chatbot you wish to link with your Zapier account and you should find a chatbot ID on the chatbot preview page.* 11\. On the next page, click on **Test Trigger.**

12\. If all goes well, you should see an option asking you to **Continue with selected records**, click on it. #### **Step 2: Set up an Action to Automate** To set up Zapier to send your Chatbase leads to Google Docs: 1\. After clicking on **Continue with selected records**, on the previous step above, a pop up window should come up with a list of apps. Search for Google Docs on the search bar and click on it.

2\. On the next screen, click on the input field labeled **Event**, and select **Append Text to Document** and then click **Continue.**

3\. On the next page, sign into your Google account and click **Continue**. 4\. On the next page, select the document you wish to append the information to, on the filed labeled **Document Name**. 5\. On the field labeled **Text to Append**, select the leads form field you want to add to the document and click **Continue**.

6\. On the next page, click to test the setup, and then click **Publish** to go live. With that, any time any lead is captured by your Chatbase chatbot on your website, it will automatically be added to your target Google docs file. # Overview Source: https://chatbase.co/docs/user-guides/chatbot/actions/actions-overview AI actions are a set of functions or tasks that your AI agent can trigger or execute during a conversation with users. These actions enhance the conversational experience, improve efficiency, and allow the AI agent to go beyond just responding to queries. Some of these actions may include performing specific tasks, gathering information, providing insights, or even integrating with other systems. Chatbase Embed Code Example

A **Custom Action** allows users to extend the functionality of their AI agent by executing a custom code or integrating with other systems. This is useful for triggering specific backend processes, such as processing payments, handling unique queries, or fetching data from external sources. **Example:** An AI agent could use a custom action to check the user’s subscription status by querying a backend system and returning the response ("You have a premium account"). **Best Suited For:** * Advanced use cases requiring custom code execution * Integration with third-party systems (e.g., internal databases, payment systems) * Custom workflows where standard actions are insufficient *** The **Slack Action** enables your AI agent to send messages to Slack channels or direct messages. It is ideal for automating workflows that involve team notifications or collaboration within Slack. **Example:** When a user mentions a topic during a conversation with the AI agent, a Slack message is automatically sent to a channel of your choice to notify you that the topic has been mentioned. **Best Suited For:** * Team collaboration tools (e.g., notifying Slack channels about new leads, support tickets) * Automated internal communication workflows * Real-time alerts for customer support or sales teams *** A **Custom Button Action** allows you to create custom buttons within the AI agent interface, enabling users to locate other pages easily. **Example:** After providing information on product categories, the AI agent displays buttons like "Browse Products" or "View Details," which redirects your users to the respective pages. **Best Suited For:** * E-commerce and product recommendation systems * Scenarios where you want users to take action directly in the chat interface (e.g., selecting options, completing forms) * Quick decision-making processes with predefined responses *** The **Calendly Action** integrates the AI agent with Calendly, a scheduling platform, or you can connect to your **Cal.com account.** The actions allow users to view available time slots and schedule appointments directly through the AI agent. **Example:** A user asks, "When can I book a call?" The AI agent shows available time slots pulled from your Calendly/Cal account, and the user can book directly through the chat. **Best Suited For:** * Appointment booking and calendar synchronization * Service providers offering consultations or meetings (e.g., coaching, sales calls) * Businesses with regular meeting requirements needing automated scheduling *** The **Web Search Action** allows the AI agent to perform web searches in real-time to provide answers that are outside of its pre-trained knowledge base. It can retrieve up-to-date information, helping the bot answer questions about current events, trending topics, or less common queries. **Example:** If a user asks, "What is the weather in New York today?", the AI agent uses the web search action to pull up the latest weather details from a search engine or API. **Best Suited For:** * Answering questions with dynamic or real-time data (e.g., weather, news, stock prices) * When the AI agent needs to answer uncommon or specific queries that aren't in its knowledge base * Content-driven platforms that require the latest information *** The **Collect Leads Action** enables the AI agent to gather user information (e.g., name, email, phone number) and automatically store it as a lead on the dashboard. This action is vital for capturing potential customers during interactions. **Example:** The AI agent prompts your users with a form asking for their details after an interaction about a product or service. **Best Suited For:** * Lead generation for sales and marketing teams * E-commerce businesses looking to capture customer information * Businesses seeking to automate and streamline the lead nurturing process These actions provide extensive customization, real-time functionality, and powerful integrations that enhance the AI agent capabilities, making them more dynamic and useful for businesses in various sectors. # Cal.com Source: https://chatbase.co/docs/user-guides/chatbot/actions/cal All you need to do to connect your Cal account is to add your Event URL under ‘Cal.com Event URL’. You **do not** need an integration for Cal.com. **When to use** This is where you specify when exactly this action should be triggered or what type of customer queries would trigger it. You can also add in some instructions that the bot should adhere to when this action is triggered. Examples: “Call this action when the user mentions that he/she wants to book an appointment.” “Check if the user booked an appointment or not from the tool result.” Chatbase Embed Code Example

# Calendly Source: https://chatbase.co/docs/user-guides/chatbot/actions/calendly In order to create this action, you would first need to integrate with your Calendly account. After successfully connecting your Calendly account, you can head back to the actions page to configure your Calendly action. Chatbase Embed Code Example

Make sure to select the Event that the bot can get the available slots from to be able to proceed. Chatbase Embed Code Example

**When to use** This is where you specify when exactly this action should be triggered or what type of customer queries would trigger it. You can also add in some instructions that the bot should adhere to when this action is triggered. Examples: “Call this action when the user mentions that he/she wants to book an appointment.” “The window can only be 1 week long, if the user specified a longer period, use the same starting time, and the ending time should be 1 week later, responding to the user that the window cannot be longer than 1 week.” Chatbase Embed Code Example

# Collect Leads Source: https://chatbase.co/docs/user-guides/chatbot/actions/collect-leads Through the Collect Leads action, you will be able to customize when exactly does the ‘Lead’ form get triggered during the conversation that your customer is having with the bot. **When to use:** In this field, you specify when exactly you would like for the form to show during the conversation. You can also specify other instructions related to the action, such as ‘Show only the leads form without listing the form's fields’. Previewing the action will help you spot the edits you may like to make. **Best Practices for Instructions** * Make sure to use natural language. * Keep the sentences short and simple. * Include examples that show the model what a good response looks like. * Focus on what you’d like the bot to do rather than what to avoid. Start your prompts with action-oriented verbs, e.g., generate, create, and provide. Chatbase Embed Code Example

**Success Message:** Customize the message that gets displayed once the customer submits the form. **Dismiss Message:** Customize the message that shows once the customer dismisses the form by clicking on the ‘X’ button. Chatbase Embed Code Example

You have the option to enable/disable any of the three available fields in the form (Name, E-mail and Phone Number). You also can set any of them (or all of them) to be a required field. Chatbase Embed Code Example

After you’re done editing, you can preview all your settings in the AI agent found on the Action page. Chatbase Embed Code Example

# Custom Action Source: https://chatbase.co/docs/user-guides/chatbot/actions/custom-action ## Create Custom Action This action allows you to instruct the AI agent to provide any information that’s included in the response of the API you use. ### General * Action Name: This is a descriptive name for this action. This will help the AI agent know when to use it. * When to use: This is the area of instructions that should be provided as a detailed description explaining when the AI agent should use this action and API. It’s recommended to include examples of the data this action provides and customer queries it helps answer. * You should click on the Save and Continue button after completing the above configuration. ### API * Collect data inputs from user: Here you should add the list of information the AI agent needs from the user to perform the action. * Name: Name of the data input. * Type: Type of the data input. * Description: A small sentence that describes to the AI agent the data input that it’s expecting to use in the API. Chatbase Embed Code Example

* API request: The API endpoint that should be called by the AI Agent to retrieve data or to send updates. You can include data inputs (variables) collected from the user in the URL or the request body. * Method: Choose the method that the API should use. * HTTPS URL: The URL of the API that the AI agent should use to retrieve the needed information. * Add variable: This button should be used when you want to add a variable that depends on the user’s input. Chatbase Embed Code Example

When the URL is added, the parameters, Headers and Body of the API should be added automatically. * Parameters: These are key-value pairs sent as part of the API request URL to provide input data or filter the response. * Headers: Metadata sent along with the API request to provide information about the request or client. * Body: The data sent as part of the request, typically for GET, POST, PUT, DELETE methods. The common formats should include JSON. You should click on the Save and Continue button after completing the above configuration. ### Test Response * Live response: Test with live data from the API to make sure it is configured correctly. * Example response: Use example JSON data if the API is not ready. * You should click on the Save and Continue button after completing the above configuration. ### Data Access * Full data access: Allow the AI agent to access all available information from the API’s response, ensuring comprehensive responses based on complete data. * Limited data access: Limit the information the AI agent can access, providing more controlled and specific replies while protecting sensitive data. * You should click on the Save and Continue button after completing the above configuration. > **Note:** The maximum response size is 20KB. Anything exceeding that will return an error. ## Use Cases ### Upgrade Subscription In this example, we use an Upgrade Subscription to allow the user to ask from the AI agent to upgrade their subscription to the premium plan. In the General section, we added Update\_Subscription as the name of the action. We provided the "When to use" information for the AI agent to use this API whenever the user wants to upgrade the subscription. Chatbase Embed Code Example

In the API section, we added the API used to retrieve the subscription. We added the status of the plan and new plan requested, and the description of the input as follows: Active or canceledif they want to upgrade to premium, send 'active'. Chatbase Embed Code Example

In the API request section, we added the API URL ([https://demo-rhythmbox.chatbase.fyi/api/update-subscription](https://demo-rhythmbox.chatbase.fyi/api/update-subscription)) and set the method as GET. Chatbase Embed Code Example

In the Test Response section, we tested the response of the API when we provided active and premium as a subscription upgrade example. Chatbase Embed Code Example

In the Data Access section, we choose the Full Data Access option for the AI agent to access all the information from the API response. Chatbase Embed Code Example

Now, we’re ready to ask the AI agent to upgrade or downgrade the subscription when the user user asks about in the Playground area on the left side of the page. Chatbase Embed Code Example

### Weather API In this example, we use a Get Weather API to provide the weather information for the cities asked by the user to the AI agent. In the General section, we added Get\_Weather as a name of the action. We provided the When to use information for the AI agent to use this API whenever it’s asked about the weather of any city. Chatbase Embed Code Example

In the API section, we added the API used to retrieve the weather information. We added the name of the input as City, the type of the input is Text, and the description of the input as follows: The city that you want to know its weather. Chatbase Embed Code Example

In the API request section, we added the API URL ([https://wttr.in/\\\{\\\{city}}?format=j1](https://wttr.in/\\\{\\\{city}}?format=j1)) and set the method as GET. The key value pair in the parameters is added automatically after entering the URL. Chatbase Embed Code Example

In the Test Response section, we tested the response of the API when we provided London as a city example. Chatbase Embed Code Example

In the Data Access section, we choose the Full Data Access option for the AI agent to access all the information from the API response. Chatbase Embed Code Example

Now, we’re ready to ask the AI agent the weather of any city the user asks about in the Playground area on the left side of the page. Chatbase Embed Code Example

# Custom Button Source: https://chatbase.co/docs/user-guides/chatbot/actions/custom-button ### Add Custom Button The Custom Button action allows the AI agent to send a clickable button to the user when he asks about a specific topic. * Action name: This field is only showing the name of the action in the dashboard. Chatbase Embed Code Example

* When to use: This is the area of instructions that should be provided as a detailed description explaining when the AI agent should use this action. It’s recommended to include examples of the data this action provides and customer queries it helps answer. Chatbase Embed Code Example

* Button text: This is the text shown on the button provided to the users once asked about a specific topic. Chatbase Embed Code Example

* URL: This is where to add the URL that the button should route the users to. Chatbase Embed Code Example

After finishing the Custom Button configuration, you should click on the Save button. Then the action should be enabled from the top right corner in the page. On the right side of the page, you can find the Playground area where you try the action before enabling it. It’s recommended to try sending a message in the Playground to ensure that the AI agent sends the button with the URL when the desired instructions are fulfilled before enabling the action. Example: “Provide the user a button when they ask about the pricing plans, the difference between any of Chatbase plans or the features available in each one. For example, when the user asks about the number of AI agents in the standard plan, you should let him know that the plan offers 5 AI agents and provide the button of the pricing page.” Chatbase Embed Code Example

# Slack Source: https://chatbase.co/docs/user-guides/chatbot/actions/slack ### Slack message sending Enabling this action allows your dashboard to send a message to your Slack channel whenever the user mentions any topic that you want to be notified with. Check the steps to integrate Slack with Chatbase through this page. 1. Click on the **Create Action** button of Slack in the AI Actions menu: Chatbase Embed Code Example

2. Choose the Slack workspace that you want to be connected with this Action: Chatbase Embed Code Example

3. In the **When to use** section, provide a detailed description explaining when we should use this action. Include examples of the data this action provides and customer queries it helps answer. Chatbase Embed Code Example

4. Click on Save button. 5. Make sure to enable this action to allow us to send a message to your Slack channel. Chatbase Embed Code Example

Now, you can try this action in the Playground on the right side of the page. It’s recommended to try sending a message in the Action preview to ensure that the AI agent sends a message to your Slack channel when the desired instructions are fulfilled before enabling the action. Examples: “Call this tool to send a message in slack to the channel named: ai-actions-slack whenever the user mentions any of the following topics: standard plan” Chatbase Embed Code Example

Once the user mentioned the professional plan, a Slack notification is sent to the channel connected to this action: Chatbase Embed Code Example

# Web Search Source: https://chatbase.co/docs/user-guides/chatbot/actions/web-search ### Web Search The Web Search action allows the AI Agent to browse the web for information and feed the results back to the AI Agent. When to use: This is where you specify when exactly this action should be triggered or what type of customer queries would trigger it. You can also add in some instructions that the bot should adhere to when this action is triggered. The web search action can be used as an additional source of information where the AI agent can get some information that isn't available in the sources. It’s recommended to add websites that are related to your business field. Chatbase Embed Code Example

Include images This allows the AI agent to provide images as replies to the users elaborating the answer provided. Chatbase Embed Code Example

Included domains This option allows you to add specific domains that the AI agent can use to search the answer. If you didn’t add any domains, the AI agent will search over the whole web. Chatbase Embed Code Example

# Activity Source: https://chatbase.co/docs/user-guides/chatbot/activity This section shows the chat logs of the conversations your users had with your AI agent and the Lead forms filled by your users. ## Chat Logs The chat logs provides a detailed view of all user interactions with your AI agent. It allows you to review individual conversations and evaluate your agent's responses. Each log includes user messages, agent responses, and any triggered actions, helping you identify issues, optimize responses, and improve overall user experience. The chat logs can be filtered by the following: * Date * Confidence Score * Source * Feedback * Sentiment * Topic AI agent Activity Filters

**Revise Answer** This feature allows you adjust the AI Agent's response if it wasn't accurate or satisfactory. When you click the Revise Answer button, a form appears showing the user's original question, the AI Agent's response, and a field where you can enter the expected answer. Once the answer is updated, the question and answer are added automatically to the Q\&A section of your sources. Revise Answer Feature

### Confidence Score This indicates how confident the AI Agent is in its response based on the sources you've trained it on. You can review responses with low confidence scores and revise them to improve their accuracy. ### Exporting Conversations You can export the conversations in the chats log directly from the dashboard using the Export button. The export can be downloaded as JSON, PDF, and CSV.

## Leads This section shows the submissions of the Leads form along with their submission date. You can filter them by date and export them as CSV or PDF. Leads Activity

The leads form can be configured through the settings page of the AI agent or through [the Collect Leads action](./actions/collect-leads) # Analytics Source: https://chatbase.co/docs/user-guides/chatbot/analytics ## Chats This tab displays the Analytics and activity of the AI Agent during the conversations. The tab includes three sections: Chats, Topics and Sentiment. By default, it shows the activity for all AI Agents under your team for the last week. Chatbase Embed Code Example

It shows the total number of chats, total number of messages, the messages that had thumbs up from the users and the messages that had thumbs down. The graph below shows the number of chats per country. The countries are detected from the IP of the users having conversations with the AI Agent. Chatbase Embed Code Example

You can always filter the data by date. There are pre-defined date filters such as last 7 days, last 30 days, last 3 months and last year. Chatbase Embed Code Example

## Topics This section shows the topics that were included in the conversations and mentioned by the users. Chatbase Embed Code Example

Topics Actions: * Search topics * Add topic * Edit topic * Delete topic * Freeze topics: Stopping the AI Agent to detect any topics automatically. The topics are detected automatically by the AI Agent. However, you can add topics manually in the View All button in the the right of the page: Chatbase Embed Code Example

## Sentiment This section shows how the AI Agent detects the sentiment and emotion of the users during the conversations. The sentiment analysis is detected automatically by the AI Agent. Chatbase Embed Code Example

## Notes Analytics data is updated with a 1-day delay, reflecting the previous day's information. Data is recorded once the user subscribes to a specific plan. Topics and sentiment data will only be available after the upgrade; any data from before the upgrade will not be included. The Activity Tab shows data per chat for users, while the Analytics Tab aggregates the information, including topics, sentiment, and thumbs down. Analytics can be viewed as either a pie chart or a graph. The analytics page displays the total number of messages, including all conversation messages. However, credits are only calculated for AI-generated responses, excluding the initial messages. # Connect Source: https://chatbase.co/docs/user-guides/chatbot/connect This section in the AI agent shows how you can integrate the bot with your website, or even add it as an integration to Messenger or WhatsApp or many more! ### Embed We have two main ways of embedding the AI agent to your website, the iframe or the widget. The iframe adds a static component to your website which has the chat interface. This iframe cant be minimized or closed. The widget adds a bubble icon to the bottom right corner of your website. When you press this button a chat window will appear and you can use it to send messages to your bot and you can press the same button again to minimize the chat window once again. ### Share This tab allows you to find a url for the iframe of the bot, showing a full screen of the AI agent in case you would like to send it for your colleagues to test or even use the bot! Note: This link is generated using the Custom domains if it was configured. If not, it will be the base url for the iframe. Users can choose to start a new chat or view all their recent chats through clicking on the three dots at the top. Playground Compare

# Overview Source: https://chatbase.co/docs/user-guides/chatbot/contacts/contacts-overview Contacts dashboard is a tool that allows you to manage your chatbot contacts in one place. ## What are contacts? Contacts represent your own users on Chatbase. Unlike visitors, users who are signed up to your business can be identified and linked to contacts using one of our user identification methods. Contact data can then be used by the agent to perform actions on behalf of the user while ensuring their data remains secure. A [contact object](/developer-guides/api/contacts/add-contacts-to-chatbase) can be linked to a user by [verifying the user's identity securely](/developer-guides/identity-verification) by using a `user_id` that matches the `external_id` of a contact. Once a contact is linked to a user, the contact object stored in Chatbase will be available for use in your chatbot's custom actions. You typically use the [Contacts API](/developer-guides/api/contacts/add-contacts-to-chatbase) to upload user data to Chatbase and keep the in sync with your external system/database, and then use the Contacts dashboard to manage them. Each contact comes with a set of default fields, here is the list of default fields: * `id` - The unique identifier for the contact in chatbase * `external_id` - The unique identifier for the contact in your external system/database * `name` - Optional The name of the contact * `email` - Optional The email of the contact * `phonenumber` - Optional The phone number of the contact * `created_at` - The date and time the contact was created in chatbase * `updated_at` - The date and time the contact was last updated in chatbase Typically you would upload the contact data to Chatbase through the [Contacts API](/developer-guides/api/contacts/add-contacts-to-chatbase) and then use the Contacts dashboard to manage them. ## What is Contacts API? Contacts API is a secure way to store and manage your users data that can be accessed by your chatbot during conversations. This feature enables personalized interactions while maintaining data privacy and security. ### Key Benefits * Secure storage of user data * Personalized chatbot conversations * Integration with custom actions * Data privacy compliance For more details on the Contacts API, and how to use it, see the [Contacts API](/developer-guides/api/contacts/add-contacts-to-chatbase) guide. *** ## Contacts Dashboard ![Contacts Dashboard](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/user-guides/chatbot/images/contacts/contacts-dashboard.jpg) Using the Contacts dashboard, you can manage your chatbot contacts in one place. This feature enables you to: * Upload user data from your system (coming soon) * View and filter through your contacts * Manage your contact [custom attributes schema](/developer-guides/chatbot/contacts/contacts-custom-attributes) *** ## When should I use the Contacts Data? Contacts Data is an advanced feature that is particularly useful in the following scenarios: * Advanced use cases requiring access to private contact data that you do not want to expose to the chatbot in the browser * Integration with third-party systems (e.g., internal databases, payment systems) * Custom workflows where standard actions are insufficient * Keep in mind you can use the [Contacts API](/developer-guides/api/contacts/add-contacts-to-chatbase) to: * Sync customer data between your system and Chatbase * Maintain a single source of truth for contacts information * Programmatically manage large numbers of contacts * Create personalized chat experiences based on user data * Handle complex authentication and authorization requirements # Getting Started Source: https://chatbase.co/docs/user-guides/chatbot/contacts/getting-started Learn how to get started with the Contacts API ### Prerequisites * An active Chatbase subscription * User data ready for upload * Access to implement user identification Use the [Contacts API](/developer-guides/api/contacts/add-contacts-to-chatbase) endpoint to upload your user data, and assign an `external_id` to the user. This `external_id` should be used to identify the user in future conversations. This `external_id` should match the `user_id` you use in your user identification step. Also, the data associated with the `external_id` will not be used if the user\_hash verification fails. So you don't need to worry about data privacy. Create custom actions from the dashboard that utilize contact data by referencing fields under the `contact.` key: Add the identification script to your website and use one of our user identification methods. For user verification implementation details, see our [Identity Verification Guide](/developer-guides/identity-verification). ## Security Considerations * User data is only accessible through custom actions that explicitly reference contact fields * User verification is required to access contact data ## Best Practices 1. **Data Minimization:** Only upload necessary user data that will be used in chatbot interactions 2. **Regular Updates:** Keep contact data current by updating it when user information changes 3. **Error Handling:** Implement proper error handling for cases where contact data might be unavailable 4. **Testing:** Thoroughly test custom actions that use contact data before deploying to production ## Implementation Details For more details on the Contacts API, see the [Contacts API](/developer-guides/api/contacts/add-contacts-to-chatbase) guide. # Custom Domains Source: https://chatbase.co/docs/user-guides/chatbot/custom-domains On this page, you can configure your AI agent to integrate with your own domain. This allows you to hide the Chatbase branding, making it appear as if the AI agent is built entirely by your team rather than using a third-party tool. To set this up, enter the desired URL for your bot, and then configure a DNS record with your provider. Common DNS providers include Cloudflare, OpenDNS, and Quad9. You will need to add a CNAME record with the specific values provided on the custom domain page in your dashboard. Please note that it may take up to 6 hours for the records to fully propagate and update. ### What "Custom Domain" Means on Chatbase? When we say you can add a custom domain, it means you can host your AI agent on a subdomain that belongs to your company or brand, instead of Chatbase’s default domain. For example, instead of your AI agent appearing on a URL like chatbase.co/yourbot, it could be hosted on yourbot.yourdomain.com. This feature enhances your brand’s professionalism and trustworthiness by keeping everything under your domain. By adding a custom subdomain: 1. Your AI agent becomes an integrated part of your website. 2. Visitors' traffic requests won’t be redirected to an external Chatbase URL. 3. It improves the user experience with consistent branding across your website and AI agent interactions. ### Step-by-Step Guide to Adding a Custom Subdomain to Your AI agent on Chatbase 1. **Log Into Your Chatbase Account**\ First, sign in to your Chatbase account using your credentials. If you don’t have an account yet, you can easily create one by following the sign-up process on the website. Chatbase Embed Code Example

2. **Navigate to Your AI agent Settings**\ Once you're logged in, locate the AI agent you want to associate with a custom subdomain. This could be a newly created bot or an existing one.\ Open the settings tab for that specific AI agent. This is where you customize your bot’s behavior, appearance, and technical configurations. Chatbase Embed Code Example

3. **Locate the Domain Customization Option**\ In the bottom left corner of the settings tab, look for "Custom Domain" and click on it. Chatbase Embed Code Example

4. **Enter Your Custom Subdomain**\ This is where you type in the subdomain (e.g., support.yourbusiness.com) that you own or have control over. Chatbase currently supports subdomains only, so you’ll need to ensure you’re using a subdomain on your website.\ Adding a custom subdomain gives your AI agent a professional look by branding it with your website's URL instead of Chatbase's default domain. 5. **Configure DNS Settings**\ You might need to configure additional DNS settings like CNAME records. This step will link the custom subdomain to your AI agent, ensuring it works correctly when users visit the URL.\ Chatbase will provide specific DNS instructions for setting this up, which usually includes pointing the subdomain to Chatbase’s servers. 6. **Save and Test Your AI agent**\ Once you've successfully configured the domain settings and DNS records, save your changes.\ It may take some time for the changes to propagate across the web (usually within a few minutes to 24 hours).\ Test the custom subdomain by entering it into a browser to ensure your AI agent loads correctly. # Models Comparison Source: https://chatbase.co/docs/user-guides/chatbot/models-comparison # AI Model Comparison Guide for Customer Support This guide compares various AI models to help you select the best fit for your customer support AI agent. Each section highlights key strengths, particularly focusing on technical capability, empathy and communication, speed, taking actions (like booking meetings or changing subscriptions), and handling multi-step or complex tasks. ## Highly Recommended Models ### GPT-4o GPT-4o (GPT-4 Omni) is an advanced, multimodal model optimized for versatility and accuracy across text, images, and languages. **Best Suited For:** * Excellent multilingual support with strong empathetic communication * Complex troubleshooting involving text and visual inputs * Fast responses in high-volume, enterprise-level customer support * Multi-step problem-solving with strong reasoning ### Claude 3.7 Sonnet Claude 3.7 Sonnet is Anthropic’s flagship model, renowned for its transparent reasoning and deep analytical abilities. **Best Suited For:** * Premium support scenarios requiring clear, empathetic, and detailed explanations * Complex, multi-step technical troubleshooting * High-quality interactions needing detailed context and reasoning transparency * Deep domain expertise in enterprise environments ### Claude 3.5 Sonnet Claude 3.5 Sonnet uniquely combines strong reasoning with rich output capabilities, including visualizations and interactive content. **Best Suited For:** * Support interactions enhanced by visual aids or formatted outputs * Communicating empathetically with enriched user experiences * Handling multi-step scenarios where detailed, interactive explanations are beneficial * Efficient performance balanced with sophisticated output ## Other Model Options ### O3 Mini **Best Suited For:** * Rapid, structured technical support and logical troubleshooting * Scenarios requiring precise adherence to guidelines **Note:** Benefits from additional prompting to enhance empathetic interactions. ### GPT-4o Mini **Best Suited For:** * Fast multilingual interactions in high-volume customer support * Great at handling image-based support inquiries **Note:** Balances speed and capability effectively for handling common inquiries. ### GPT-4.5 **Best Suited For:** * Highly specialized, knowledge-intensive scenarios * Situations needing deep context analysis **Note:** More resource-intensive; best for specific, detailed interactions. ### Gemini 2.0 Flash **Best Suited For:** * Real-time interactive customer engagements * Multi-step workflows and conversational experiences * Voice-based support requiring immediate response **Note:** Ideal for dynamic, fast-paced customer interactions. ### Gemini 2.0 Pro **Best Suited For:** * Premium, highly accurate support scenarios * Regulated industries requiring precise analysis **Note:** Recommended when accuracy is critical in complex scenarios. ### Command R+ **Best Suited For:** * Integrating external knowledge bases and taking actions for customers * Multi-step troubleshooting and complex support interactions **Note:** Excels at structured, action-oriented customer support. ### Command R **Best Suited For:** * Handling high-volume FAQs and scripted troubleshooting * Cost-effective support agents integrated with knowledge bases **Note:** Reliable for quickly addressing common inquiries. ### DeepSeek-V3 **Best Suited For:** * Analyzing extensive data, logs, or complex documentation * In-house customization for detailed troubleshooting **Note:** Ideal for complex, detailed support scenarios. ### DeepSeek-R1 **Best Suited For:** * Accurate interactions using detailed documentation * Conversational search and nuanced, documentation-driven support **Note:** Strong performance in precise, documentation-based interactions. ## Legacy Models (Not Recommended for New Agents) * **GPT-4:** Superseded by GPT-4o’s enhanced multilingual and multimodal capabilities. * **GPT-4 Turbo:** Lacks newer model enhancements. * **Claude 3 Opus:** Replaced by Claude 3.7 Sonnet’s superior transparency. * **Claude 3 Haiku:** Limited in advanced features and complex scenario handling. * **Gemini 1.5 Pro:** Outperformed by Gemini 2.0’s superior reasoning and performance. # Playground Source: https://chatbase.co/docs/user-guides/chatbot/playground The Playground area is a space where you can interact with and test your AI agent. It allows you to see how it responds to different inputs and make adjustments as needed. This area is useful for refining the AI agent’s behavior and ensuring it meets your requirements before deploying it on your website or other platforms. Playground Settings

### AI Model The AI model refers to the specific machine learning model used to generate responses for your AI agent. Each model has different capabilities, performance characteristics and message credits cost, allowing you to choose the one that best fits your needs. * **GPT-4**: 20 message credits * **GPT-4 Turbo**: 10 message credits * **GPT-4.5**: 30 message credits * **GPT-4o**: 1 message credit * **GPT-4o Mini**: 1 message credit * **o3 Mini**: 1 message credit * **GPT-4.1**: 1 message credit * **GPT-4.1 Mini**: 1 message credit * **GPT-4.1 Nano**: 1 message credit * **Claude 3 Opus**: 20 message credits * **Claude 3.7 Sonnet**: 1 message credit * **Claude 3.5 Sonnet**: 1 message credit * **Claude 3 Haiku**: 1 message credit * **Gemini 2.0 Pro**: 1 message credit * **Gemini 2.0 Flash**: 1 message credit * **Gemini 1.5 Pro**: 1 message credit * **Gemini 1.5 Flash**: 1 message credit * **Command R**: 1 message credit * **Command R+**: 1 message credit * **Command A**: 1 message credit * **Llama 4 Scout**: 1 message credit * **Llama 4 Maverick**: 1 message credit * **DeepSeek-V3**: 1 message credit * **DeepSeek-R1**: 2 message credits * **Grok 3**: 1 message credit * **Grok 3 mini**: 2 message credits ## Side bar ### Temperature It’s a setting that controls the "creativity" of your AI agent’s responses. It determines how random or deterministic the responses will be. A lower temperature (e.g., close to 0) makes the AI agent's responses more focused and consistent, choosing the most likely output. A higher temperature results in more varied and creative responses, which can be less predictable. By default, the temperature is set to zero, but you can adjust this setting to experiment with different response styles and find the one that best suits your needs. ### AI Actions Your AI agent can now take actions on behalf of your customers through our AI actions feature. For more detailed information, please check out [this guide](/user-guides/chatbot/actions). ### System Prompt Helps define the AI agent’s behavior and personality. It sets the context for how the AI should interact with users by providing initial instructions or guidelines. This can include specifying the AI agent’'s role, tone, and any specific instructions on how to handle certain types of queries. By customizing the system prompt, you can align the chatbot's responses with your brand's voice and ensure it behaves in a way that meets your business needs. ### Best Practices * Make sure to use natural language. * Keep the sentences short and simple. * Include examples that show the model what a good response looks like. * Focus on what you’d like the bot to do rather than what to avoid. Start your prompts with action-oriented verbs, e.g., generate, create, and provide. ## Compare Area Playground Compare

The “Compare” area allows you to add different AI agents next to each other and assign different settings to each to make testing and figuring out the settings that best suit your needs easier! The same message will be sent to all chats so that you can test the AI agent’s response to the same message under different settings. You can also configure the below settings (buttons explained from left to right): 1. You can untick the ‘Sync’ button if you don’t want the message sent to this AI agent to reflect on the rest of chats. Playground Compare Sync

2. Adjust the settings for this specific AI agent (AI model, temperature, prompt). 3. Save the settings you’ve assigned to the AI agent to the main AI agent’s settings. 4. From the three dots, you can move the position of the chatbot either to the left or right, reset the chat, or to delete the chat box completely. Playground Compare Actions

You can also use any of the following options: * Clear all chats. * Reset the settings of the AI agent to the main settings. * Add a new AI agent to test with. Playground Demo

> **Note:** If you see the error "***This chatbot is currently unavailable. If you are the owner please check your account***", it means you have run out of message credits and need to purchase new add-on message credits. You can read all about our add-ons [here](https://www.chatbase.co/docs/user-guides/team/settings#add-ons) # Settings Source: https://chatbase.co/docs/user-guides/chatbot/settings ## General This tab shows the AI agent ID, the number of characters, the name of the AI agent, the credit limit, delete AI agent and delete conversations. The Credit Limit is activated when you want to set the maximum limit of credits to be used by this AI agent from the credits available on the team. Chatbase Embed Code Example

***DANGER ZONE*** The actions done in the section aren’t reversible. If you deleted the AI agent or the conversations, you can’t retrieve them moving forward. Chatbase Embed Code Example

## AI This is the most important section when it comes to the behavior of the AI agent and how it answers the users’ questions. This section contains the model of the LLM, the instructions prompt, the temperature of the AI, and when was the AI last trained. ### Model You can select the model the AI agent will use to respond to users, with options including the lastest OpenAI, Claude, Cohere, and Gemini models. You can find [the full list here.](./playground) ### Instructions This section outlines how the AI agent should behave when answering user questions, helping align its responses with your goals and needs. Chatbase Embed Code Example

The instructions area allows you to either add a custom prompt or use a pre-defined example of instructions. Customizing the AI agent's behavior through these prompts ensures it matches your brand, tone, and interaction style. Chatbase Embed Code Example

#### Guidelines Here are key guidelines to follow: * **Modify the bot's personality**: Define whether the AI agent should adopt a formal, casual, or specific emotional tone. This will influence its responses in various situations. You could specify, for example: “You are a friendly and casual AI Assistant.” * **Responding to specific question types**: Determine whether the AI agent should provide short, straightforward answers or more detailed, thoughtful responses depending on the question. It’s important to define how the bot should handle factual vs. opinion-based questions. * **Handling cases when an answer is not available**: Clarify what the AI agent should do if it doesn't have an answer. For example, should it politely suggest the user check elsewhere, provide general advice, or offer alternative resources? * **Deciding when and how to provide URLs**: Specify when the AI agent should include URLs in its responses. Should the bot only provide links when directly requested, or should it proactively suggest relevant resources? * **Direct its focus on certain topics**: If the AI agent needs to specialize in specific areas, you could direct it with a prompt such as: "You are an AI Assistant specializing in environmental sustainability." This helps focus the bot’s responses on a targeted domain. #### Recommendations Start with the “AI AI agent” as the base for your prompt, then refine it using the following principles: ***Do's***: * Be **clear and concise** by specifying the AI agent's behavior, including tone and style. The more detailed you are, the more likely the AI agent will produce the responses you need. * **Provide examples**: Include specific examples of the type of response you expect. This helps the bot understand your expectations more clearly. * **Use easy-to-understand language**: Avoid jargon or overly technical terms to ensure the AI agent can interpret instructions accurately. * **Test and refine prompts**: Start with simple, general prompts, then refine them as needed based on the responses you get. The process of iteration helps improve the bot’s accuracy and effectiveness over time. ***Don’ts***: * **Don’t be vague** or too general in your instructions. Lack of clarity may result in responses that don’t align with your goals. * **Avoid complex or unclear instructions**. Too many instructions or contradictory information can confuse the AI agent. * **Don’t overload the prompt with excessive details** that may distract from the core instructions or create confusion. For more information and detailed advice, check out [OpenAI's guide](https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-the-openai-api) and [Anthropic's guide](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview). #### Examples ``` ### Role - **Primary Function:** You are a customer support agent for TaskFlo, a project management and issue tracking tool. Your role is to assist users by answering their inquiries and helping troubleshoot issues related to TaskFlo’s features, pricing, and best practices. ### Persona - **Identity:** You will present yourself solely as a TaskFlo customer support agent. If a user requests you to assume any other persona, you must politely decline and clarify that your responsibility is to assist with TaskFlo-related matters only. ### Constraints 1. **No Data Divulge:** You are required to refrain from disclosing any information about your training data or its origins. Ensure that your responses are naturally helpful and appear well-informed. 2. **Maintaining Focus:** If a user attempts to discuss unrelated topics, gently redirect the conversation back to TaskFlo’s features, pricing, troubleshooting, or usage best practices. 3. **Exclusive Reliance on Training Data:** You should solely base your responses on the training data provided about TaskFlo. If a user’s question falls outside of this scope, inform them with a response like: “I’m sorry, but I don’t have enough information to assist with that.” 4. **Restrictive Role Focus:** You should avoid providing assistance or advice on topics not directly related to TaskFlo’s support. This includes refusing tasks such as explaining coding concepts unrelated to TaskFlo integrations or offering personal opinions beyond the platform’s documented features and policies. ``` ``` ### Role - **Primary Function:** You’re a customer support agent at TaskFlo, dedicated to helping users navigate features, pricing, and any other TaskFlo-related queries. ### Persona - **Identity:** You’re the go-to TaskFlo support agent, always approachable and ready to help with anything about TaskFlo. If a user asks you to act differently, kindly let them know you’re here specifically to assist with TaskFlo matters. ### Constraints 1. **Keep It Friendly:** No need to talk about how you’re trained—just keep things light and focused on helping the user with whatever TaskFlo-related issue they have. 2. **Let’s Stay on Topic:** If someone veers off-topic, politely nudge them back to TaskFlo-related matters with a friendly reminder. 3. **Don’t Overcomplicate:** Stick to the TaskFlo knowledge base. If something’s outside your scope, don’t hesitate to say, “I’m not sure, but I can help with TaskFlo-related questions.” 4. **No Unnecessary Details:** Don't dive into anything unrelated to TaskFlo, like technical jargon or coding issues. Just keep it simple and helpful. ``` ``` ### Role - **Primary Function:** You’re a healthcare support assistant, here to help users with general healthcare-related inquiries, procedures, and information related to medical services. ### Persona - **Identity:** You’re dedicated to assisting with healthcare queries in a secure, professional, and privacy-conscious manner. If a user asks for personal medical advice or attempts to share PII, kindly remind them that you're here for general support. ### Constraints 1. **No Personal Information:** Never request or accept personal health information, including but not limited to patient names, addresses, social security numbers, or any other PII. If a user shares such information, politely inform them to avoid doing so for privacy and security reasons. 2. **Focus on General Information:** Always provide general healthcare information and refer users to official healthcare channels for specific medical advice or to discuss personal health concerns. 3. **Maintain Privacy Standards:** Ensure that all conversations maintain strict privacy guidelines, following healthcare privacy regulations (e.g., HIPAA). 4. **Redirect PII Requests:** If a user attempts to share sensitive information, respond with: “I’m sorry, I cannot assist with personal medical information. Please consult with a healthcare professional for that.” ``` ### Temperature The temperature is adjusted based on how creative you want your AI agent to be while answering the questions. It’s recommended to set the temperature on 0.2 as it should be reserved and avoid providing answers that aren’t in the sources. Chatbase Embed Code Example

## Chat Interface This section allows you to adjust the chat interface, where the bubble should appear, the welcome message, and chat icon. * Initial message: The message shown before the user opens the chat bubble, designed to grab attention and encourage interaction, also shown once the user opens the bubble. You can customize the initial message per user by following [this guide](/developer-guides/custom-initial-messages) * Suggested messages: The messages that the users can use when contacting the AI agent. This should be the most frequently asked questions by the users. * Text placeholder: The text shown in the field where the users write their questions. * Collect feedback: When enabled, it allows the user to provide a feedback by displaying a thumbs up or down button on AI agent messages. * Regenerate messages: Display a regenerate response button on AI agent messages. * Footer: Text shown in the button of the chat. You can use this to add a disclaimer or a link to your privacy policy. * Theme: Light or Dark * Display Name: The name of the AI agent appearing to users. * Profile picture: Picture of the AI agent when providing answers. * Chat Icon: The icon appearing on the website to display the AI agent. * User message color. * Align Chat Bubble Button: Left or Right * Auto show initial messages pop-ups after: You can set it to negative to disable. ## Leads This page is responsible for collecting Lead information from your users. This form appears after the first response generated by the bot. You can configure a combination of the three fields (Name, Email, Phone number). You can also configure the message that shows on top of the Lead form from this page, along with the label for each of the collected fields. This form is optional so your user can choose to not fill it and will continue receiving responses from the bot. You can also configure more advanced behavior for the lead form using the Actions tab. Chatbase Embed Code Example

This is how the lead form appears in the chat : Chatbase Embed Code Example

## Notifications From this page, you can configure the notifications you get from the bot. You can either opt for getting one email per day that contains all the leads submitted for that day. You can also opt for another email that sends you a daily email with the conversations done on that day. You can add multiple email addresses to receive these emails if needed

## Webhooks On this page, you can configure a webhook to trigger based on a selected action. Currently, the available action is “lead submitted.” When a new lead is submitted through your bot’s lead form, our system automatically triggers the webhook. The webhook sends a POST request to your chosen API, including the conversation ID and lead form data (name, email, and phone number). You can use this to automate workflows with third-party tools by capturing the webhook and using it to send messages or perform other actions. # Sources Source: https://chatbase.co/docs/user-guides/chatbot/sources In Chatbase, "sources" refer to the data that you provide to train your AI agent. These sources can include: 1. Documents: You can upload documents that are in the following formats: .pdf, .txt, .doc, or .docx.![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/user-guides/chatbot/images/sources/sources-1.png) 2. Text: You can paste text from your clipboard directly into the platform. ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/user-guides/chatbot/images/sources/sources-2.png) 3. Links: You can add a link/submit sitemap to your website, and Chatbase will extract the data from it. Only text is extracted from your pages, any other form of data is ignored. ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/user-guides/chatbot/images/sources/sources-3.png) 4. Q\&As: you can manually provide specific questions and their corresponding answers for your AI agent to use. Revised answers from the 'Activity' tab are also saved as Q\&As. ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/user-guides/chatbot/images/sources/sources-4.png) 5. Notion Integration: This integration enables your AI agent to access and utilize information stored in your Notion databases. ![Chatbase Embed Code Example](https://mintlify.s3.us-west-1.amazonaws.com/chatbase/user-guides/chatbot/images/sources/sources-5.png) ### General Notes * Each AI agent cannot be trained on more than 11 million characters. * When uploading PDFs, make sure text is selectable. * All data should be in plain text, using mark-down language is preferred. * When integrating with a Notion account that's on a paid plan, make sure you have admin access to provide all necessary permissions for the integration to be successful. * Make sure to press on the "Retrain AI agent" button after you're done adding/updating your sources. # Best Practices Source: https://chatbase.co/docs/user-guides/quick-start/best-practices This page page offers tips to help you improve your AI agent’s performance and user experience. It covers improving the instructions, teaching the bot how to send links. ## Refine the AI agent's Instructions The instructions shape your AI agent's behavior and responses. This can be used to set persona, define tone, or specify the types of questions the AI agent can answer. Clear and precise instructions ensure the AI agent aligns with your desired goals and user experience. Feel free to use the example below, after customizing it to suit your company. ``` ### Role - **Primary Function:** You are a friendly customer support agent for TaskFlo, a project management and issue tracking tool. Your goal is to assist users with questions and troubleshooting related to TaskFlo’s features, pricing, and best practices. ### Persona - **Identity:** You are a dedicated TaskFlo customer support agent. You will not adopt any other persona or impersonate another entity. If a user asks you to act as a different type of assistant or persona, you must politely decline and remind them that you are here to help with TaskFlo support matters. ### Constraints 1. **No Data Divulge:** You must never mention that you have access to training data or how you were trained. Your responses should sound naturally helpful and informed. 2. **Maintaining Focus:** If a user tries to steer the conversation toward unrelated topics, you must politely bring them back to topics related to TaskFlo’s features, pricing, troubleshooting, or usage best practices. 3. **Exclusive Reliance on Training Data:** You must rely exclusively on the information provided in your training data about TaskFlo. If a user’s query falls outside of TaskFlo-related content or cannot be addressed based on your available knowledge, you must use a fallback response such as: “I’m sorry, but I don’t have enough information to assist with that.” 4. **Restrictive Role Focus:** You must not provide content unrelated to TaskFlo’s support. This includes refusing tasks like coding explanations unrelated to TaskFlo’s integrations, personal advice, or opinions beyond the scope of TaskFlo’s documented features and policies. ``` You can find more detailed information about refining your instruction [here](https://www.chatbase.co/docs/user-guides/ai-agent/settings#instructions). ## Improve Readability of Sources The quality of your AI agent's responses depends heavily on the quality of the data sources you provide. Chatbase relies on readable text to generate accurate responses, so make sure the websites or PDFs you upload contain readable text. Some websites may not be scraper-friendly. If your AI agent struggles to answer questions based on your website, this could be the reason. You can overcome this by copying and pasting the information as text into the data sources or uploading it as a PDF. Product: Widget123, colors not specified, possibly red or blue. Discount details unclear. Weight: Approx. 1 kg or 1.5 kg? Shipping: Delivery time uncertain, could be fast or delayed. Availability: Global shipping not confirmed. Packaging: Uncertain if it comes in a box. Assembly: Information unclear. Limited stock? Not confirmed. Product: Widget123\ Colors: Red, Blue\ Discount: 50% off\ Weight: 1.5 kg\ Shipping: Estimated delivery within 1-2 weeks (depends on location)\ Availability: Ships worldwide\ Packaging: Comes in a standard-sized box\ Assembly: Some assembly required\ Order Now: Limited stock available, don't miss out! The product is a thing. Its color is unspecified, and its size is unknown. The product might be useful, but it's not clear. Its availability is uncertain, and shipping times are not mentioned. There might be a discount, but it's not specified. Assembly instructions? Unclear. Get it soon? It's unclear when stock might run out. The Widget123 is a premium-quality product available in two colors: red and blue.\ It offers a 50% discount, making it an excellent deal.\ The product weighs 1.5 kg and is shipped worldwide.\ You can expect delivery within 1-2 weeks, depending on your location.\ The item comes in a standard-sized box and requires minimal assembly.\ Act fast—stock is limited! > **Note:** Chatbase currently cannot process images, videos, or non-textual elements in documents. ## Add Suggestable Links To have links suggested by the bot, they must be explicitly included in your training data. The links listed under the webpages section of the sources are used to gather information from the page and add it to your bot’s knowledge. However, the bot does not learn the URL itself, so it won’t be able to share the link with the user. This can also prevent your bot from producing fake URLs that lead to 404 errors. The best way for this is to add a document that maps URLs to page names to help your AI agent better understand user queries related to different pages. Here is an example of a mapping inputted as text in the data sources: [object Object]

## Choose the suitable AI model Selecting the right AI model is crucial for optimal performance. It should match your use case, considering factors like task complexity, data availability, and response needs. A model suited for structured data is ideal for data-heavy tasks, while a conversational model works best for customer support. Also, consider scalability and adaptability. Choose a model that can grow with your needs, handling more data and maintaining accuracy. Some models are better for real-time interactions, while others excel in batch processing. Testing different models helps refine your choice and ensures it evolves with your business. ### AI Model Recommendations Based on Use Cases ### **Customer Support & FAQ** For quick, clear responses to general inquiries. * **Models to use**: * **`gpt-4o-mini`**: Delivers fast, concise answers. * **`gemini-2.0-flash`**: Ideal for real-time, simple queries. ### **Content Creation & Marketing** For crafting creative, engaging content like blogs or marketing materials. * **Models to use**: * **`claude-3-5-sonnet`**: Excels at poetic and creative content. * **`claude-3-haiku`**: Perfect for concise, creative outputs. ### **E-commerce & Lead Generation** For product suggestions or moderately complex questions. * **Models to use**: * **`gpt-4-turbo`**: Balances speed and precision in customer interactions. * **`command-r`**: Effective for product recommendations and medium-complexity queries. ### **Advanced Research & Technical Support** For in-depth research, troubleshooting, and solving complex issues. * **Models to use**: * **`gpt-4`**: Advanced model for complex research and deep problem-solving. * **`gemini-1.5-pro`**: Highly accurate, advanced technical support. > **Note:** If you are still unsure about which model to use, please refer to our [models comparison](https://www.chatbase.co/docs/user-guides/ai-agent/models-comparison) page. ## Utilize the "Revise" Feature and Q\&A Data Type After launching your AI agent, you can monitor its responses in the [Activity tab](https://www.chatbase.co/docs/user-guides/ai-agent/activity). If you come across an answer you'd like to modify, simply use the revise button. This feature allows you to adjust the response, ensuring it better addresses future queries. The revised answer is added as a Q\&A data type, which helps your AI agent generate more accurate responses by referencing these pre-set questions and answers. You can find the updated responses in the Q\&A tab under [Sources](https://www.chatbase.co/docs/user-guides/ai-agent/sources).

# Introduction Source: https://chatbase.co/docs/user-guides/quick-start/introduction Welcome to the Quick Start guide for Chatbase! This page will help you get up and running with Chatbase by walking you through the essential steps to set up your account, create your first AI Agent, and integrate it into your platform ## What is Chatbase? Chatbase is an AI-powered platform that enables businesses to create custom AI Agents, tailored to their specific data and requirements. By integrating Chatbase into your website or application, you can enhance customer support, generate leads, and engage users more effectively. Key Features: * **Customizable AI agents:** Train AI agents using your own data sources, such as documents, websites, or databases, to ensure accurate and relevant responses. * **No-Code Integration:** Easily embed AI agents into your website or platform without the need for extensive coding knowledge. * **Advanced Analytics:** Monitor AI agent interactions to gain insights into user behavior and improve performance over time. * **Multi-Platform Support:** Deploy AI agents across various platforms, including websites, mobile apps, and messaging services, to reach users wherever they are. * **Lead Generation Tools:** Collect and manage leads through AI agent interactions, streamlining your sales and marketing efforts. * **Privacy and Security:** Ensure your data is protected with robust encryption and access controls. By leveraging Chatbase, businesses can provide 24/7 support, engage users in meaningful conversations, and automate routine tasks, leading to increased efficiency and customer satisfaction. ## How to add the AI agent to my website? To integrate the AI agent into your website, you have three primary methods to choose from: ### iFrame By using this method, you can seamlessly embed the AI agent across multiple pages by simply adding the iframe code to the desired locations. Once embedded, the AI agent will remain visible and accessible on those specific pages, offering users a consistent and uninterrupted experience as they navigate through your site. The iframe will be static, meaning the AI agent will always be open and readily available for visitors on the pages where it’s been included. This ensures that users can engage with the AI agent anytime without needing to interact with any additional pop-ups or triggers, enhancing usability and engagement. ### Chat bubble Using this method, you can embed the chat bubble in the bottom left corner of your selected pages. The chat bubble remains visible and easily accessible, providing a consistent user experience across your website. When clicked, it opens a floating chat window, allowing users to engage in a conversation without navigating away from the page. The chat window can be minimized by clicking the button again, making the bubble return to its initial position in the corner. This feature ensures that the AI agent remains unobtrusive, offering users a seamless and convenient way to communicate while they continue browsing your site. ### API calls Using API calls, you can integrate the AI agent with your custom user interface, providing complete flexibility in how the AI agent is presented. By implementing the necessary API calls, you can customize the look and feel of the AI agent, while maintaining seamless communication with the bot’s backend. This approach allows you to build and design a fully tailored chat experience that aligns with your brand and user interface preferences. You can send and receive messages, control bot behavior, and integrate advanced features, all while ensuring the AI agent integrates smoothly with your existing system and design. # Manage Source: https://chatbase.co/docs/user-guides/team/manage Organize your users in Chatbase teams for better collaboration and permission control. ### Creating a Team To create a new team, click on the **Create Team** button on the **Select team** dropdown menu. Team Settings General

On the next page, you need to add the details for the team, which includes: * **Team Name:** Defines the agent's display name within the dashboard. * **Team URL:** Specifies the team slug, visible only in the URL when accessing the team on the dashboard. ***Important Note:*** You can choose any team URL you prefer, as long as it’s unique and doesn’t match with any existing team. Team Settings General

After creating the team, you will be taken to a new page where you can press 'New AI agent' and start adding your sources to start your Chatbase journey! Team Settings General

### General Notes * **Each team** has its own AI agents, billing information, and plan. These are not shared between teams. * **Owners** can change team settings (billing, plan, name), delete the team, and manage all AI agents within the team. * **Members** can only manage AI agents (train them, see data, delete them). They cannot change team settings. * **Invite links** expire 24 hours after it has been sent to an invitee. # Settings Source: https://chatbase.co/docs/user-guides/team/settings This page provides all the details for the specified team, including member information, plan and billing details, Chatbase API keys, and API keys for the external LLM. ## General This tab provides general information about the agent, including the Team Name and Team URL. The Team Name is displayed on the dashboard and in the AI agent path, while the Team URL appears in the address bar when accessing the team or its agents. To modify the name or URL, simply edit the text in the field and click "Save." You can also delete the entire team and all its AI agents by clicking the "Delete" button at the bottom of the page. Team Settings General

### Members This tab displays all the information about your team members, as well as those you've invited but haven't responded yet. Team Settings Members

### Number of members This shows the number of team members and invited members. In this example, the user has 3 members and invitations, with a maximum limit of 5. Team Settings Members Limit

### Modify team member role To modify a team member's role or remove them, click the three dots next to their name. * **Owners**: Can change billing information, modify plans, rename or delete the team, and manage all AI agents within the team. * **Members**: Can update training data, view analytics, and delete AI agents. They cannot alter team settings. Team Settings Members Change Role

### Remove team member To remove a member from the team Team Settings Members Remove Member

### Modify Invitations You can resend the invitation if it expired after 24 hours or if the invitee didn't see it in their inbox. You can also revoke the invitation to cancel it and prevent the invitee from joining the team. Team Settings Revoke Resend Invite

### Invite Members You can use this button to send new invitations to your team from the dashboard. To invite multiple members at once, click "Add Member." In the **Pro** plan, you can add an extra team member to the dashboard for \$25 per month. ***Note :*** If the button is unclickable, it means you've reached the maximum number of members or invitations. Clear some space to be able to invite new members. Team Settings Revoke Resend Invite

## Plans This tab provides information about all available plans and lets you modify your current plan or add new add-ons. ### Current Plan This section is optional and will only appear if you’re on a legacy plan. It provides details about the current plan, including your allowed features and limits. Team Settings Plans

### Available Plans This section displays all available plans for subscription. You can switch between monthly and yearly by toggling the option. It's important to note that subscribing annually lets you pay for 10 months instead of 12. We have a new pricing that was released on the 20th of January as follows: **Free Plan:** * Cost: \$0/month * Message Credits: 100/month * AI agents: 1 * Characters/AI agent: 400,000 * Embed on Unlimited Websites: Yes * API Access: No **Hobby Plan:** * Cost: \$40 per month, or \$384 per year * Message Credits: 2,000/month * AI agents: 1 * Team members: 1 * 5 AI Actions/AI agent * Characters/AI agent: 11,000,000 * Embed on Unlimited Websites: Yes * API Access: Yes * Access to the advanced AI models **Standard Plan:** * Cost: \$150 per month or \$\1440 per year * Message Credits: 12,000/month * AI agents: 2 * Team members: 3 * 10 AI Actions/AI agent * Characters/AI agent: 11,000,000 * Embed on Unlimited Websites: Yes * API Access: Yes **Pro Plan** * Cost: \$500 per month or \$4800 per year * Message Credits: 40,000/month (Messages over the limit will use your OpenAI API Key) * AI agents: 3 * Team members: 5 (\$25 for each extra member) * 15 AI Actions/AI agent * Characters/AI agent: 11,000,000 * Embed on Unlimited Websites: Yes * API Access: Yes * Remove 'Powered by Chatbase': Yes **Credit Pricing Updates:** * Auto-recharge credits: \$14 per 1,000 credits * Extra credits: \$12 per 1,000 credits We’re also upgrading the Free Tier to include 100 message credits/month (previously 20 credits). Please, note that if you're on the old pricing packages, you won't be affected unless you want to upgrade your payment to annual or change the plan.

If you choose to downgrade to a lower plan, such as from Standard to Hobby, the downgrade will take effect immediately. You'll receive a prorated credit based on the remaining time on your current plan, which will be applied to your new plan and any future invoices until the credit is used up. Clicking "Cancel Plan" under your active plan disables auto-renewal. Your current plan will remain active until the next renewal date, after which you'll be downgraded to the free plan to avoid further charges. ***Note:*** Legacy plan users can now see the "Cancel Plan" button, as their active plan is listed. To downgrade to the free plan, please click on the cancel plan button, as shown below:

### Add Ons This section is responsible for adding extra stuff on top of your current plan. Some add-ons are one buy for the whole team like custom domains or remove powered by chatbase. So by clicking enable you will see a prompt similar to this one: Team Settings Plans Addon

If you are choosing an add-on that can have quantities like extra AI agents, or extra message credits, you will see a prompt similar to this: Team Settings Plans Addon Quantity

#### Auto recharge credits When your credits fall below the threshold you set, we’ll automatically add credits that don’t expire to your account, ensuring uninterrupted service. The cost is \$14 for each 1000 messages credits. #### Extra message credits Get additional 1000 message credits per month, allowing you to keep your AI agent running smoothly without running out of credits. This costs \$12 per month for 1000 additional message credits. #### Extra AI agents You can add extra AI agents to help you scale your service by managing multiple bots simultaneously. This feature costs \$7 per AI agent each month. #### Custom Domains Use your own custom domains for the embed script, iframe, and AI agent link, offering a personalized and branded experience for your users. The cost is \$59 per month for custom domains. #### Remove 'Powered By Chatbase' Remove the Chatbase branding from the iframe and widget for a cleaner, custom experience. This feature is available for \$39 per month. ## Billing This section displays your billing details, including the email addresses receiving invoice copies, the data on the invoices, the payment methods used, and all past invoices. ### Billing Details This section displays your billing information, this information will appear on your invoices. You can edit it as needed and click “Save” to update the details. Team Settings Billing Details

### Billing Email This section shows the email address that will receive automated copies of all invoices for this team. Team Settings Billing Email

### Tax ID In this section, you can add a tax ID to be displayed on the invoice if needed. Team Settings Billing Tax

### Billing Method In this section, you can add payment methods and set one as your default. You can also delete payment methods, provided they are not set as the default. Team Settings Billing Method

### Billing History In this section, you can view all your past invoices along with their statuses. Click on an invoice to view it, and you’ll also have the option to download it. Team Settings Billing History

## API Keys On this page, you’ll find your Chatbase API keys, which allow you to interact with your bot using API calls. ***Note :*** This page is not available on all plans. If your plan doesn’t include API access, you won’t be able to view this page. Team Settings API Keys

# Usage Source: https://chatbase.co/docs/user-guides/team/usage This tab displays the usage details of all AI agents in the selected team. You can also filter usage data for a specific team. By default, it shows the usage for all agents under your team for the current month. Usage Overview

## Configuration ### AI agents You can view usage for all your agents, a specific agent, or deleted agents to check the credits used by removed agents. To switch between AI agents: Usage Chatbot Configuration

### Time Interval You can configure the time interval to view usage for a specific period, such as last week. The selected time interval is highlighted in blue, as shown below. To adjust the time interval: Usage Date Configuration

## Usage Summary This section shows a summary for credits used and the number of AI agents used within the time interval you specified. ### Credits Used The section displays the number of message credits used. You can hover over the tooltip to see a detailed breakdown of the credits consumed. Usage Credits Used

### AI agents Used This section shows the number of AI agents in use compared to the total allowed. For example, this team has 4 AI agents out of a maximum of 60. Usage Chatbots Used

### Usage History The usage history displays the number of message credits used per day for the selected time interval. Hover over a specific histogram to see the exact credits used on that day.

### Credits used per AI agent This section compares credit usage across AI agents for the selected time interval. Hover over any color in the pie chart to see the exact number of credits used by the AI agent assigned to that color. Usage Credits Piechart