# Bootstrap visitor access Source: https://docs.webless.ai/api-reference/latest/agent/bootstrap api-reference/openapi-agent-runtime.json POST /webless/v1/bootstrap Exchange your index ID and a browser session ID for a Bearer access token. The token is bound to the Origin of the page that calls this route. ``` **Where to find it** * Go to **Design Studio** -> **Forms** * Open the form * Click **Form Actions** -> **Embed Code** **Example** ```html theme={null} ``` **Where to find it** * Go to **Content** -> **Forms** * Open the form * Click **View Embed Code** **Example** ```html theme={null} ``` **Where to find it** * Open your WordPress admin * Go to **Forms** * Use the form ID shown next to the form name **Example** ```text theme={null} [gravityforms id="1" title="false" description="false"] ``` **Where to find it** * Open the form * Click **Share** -> **Embed in a web page** **Example** ```html theme={null}
``` **Example** ```html theme={null} ``` **JavaScript** ```html theme={null} ``` **iFrame** ```html theme={null} ``` **Microsoft Forms** ```html theme={null} ``` **Google Forms** ```html theme={null} ``` **Where to find it** * Go to **Assets** -> **Forms** * Open the form * Click **Actions** -> **View Form HTML** **Example** ```html theme={null}
``` If you use a custom form builder, send Webless one of the following: * A JavaScript embed snippet * An iFrame embed snippet * The hosted form URL ## What to send Webless * The complete embed script or iFrame code * The form platform name * The form name * Any campaign or tracking IDs you want associated with submissions ## FAQ That is fine. Send the form URL to Webless and ask whether it can be embedded through an iFrame. Form platforms change their embed output over time. Copy the full code your platform provides and send that version directly. That is normal. `//` is a protocol-relative URL. Do not replace it with a single slash. # Listen to Webless analytics events Source: https://docs.webless.ai/guides/event-listeners Subscribe to Webless lifecycle events in the browser and forward them to your analytics stack. Webless emits DOM custom events with the `webless:` prefix and a structured `event.detail` payload. ## Add listeners after Webless initializes ```javascript theme={null} const eventTypes = [ "session_start", "searchbar_visible", "searchbar_hidden", "searchbar_close", "searchbar_click", "suggested_question_click", "tile_click", "click_cta", "floating_button_visible", "floating_button_click" ]; eventTypes.forEach((eventType) => { document.addEventListener(`webless:${eventType}`, (event) => { console.log(`[Webless Event: ${eventType}]`, event.detail); // Forward to your analytics service here. // analytics.track(eventType, event.detail); }); }); ``` ## Supported events | Event | Fired when | Core fields | | - | - | - | | `webless:session_start` | A new user session starts | `sessionId`, `timeStamp`, `eventType` | | Event | Fired when | Core fields | | - | - | - | | `webless:searchbar_visible` | The search bar enters the viewport | `sessionId`, `location`, `timeStamp`, `eventType` | | `webless:searchbar_hidden` | The search bar leaves the viewport | `sessionId`, `location`, `timeStamp`, `eventType` | | `webless:searchbar_close` | A user closes the floating search bar | `sessionId`, `location`, `timeStamp`, `eventType` | | Event | Fired when | Core fields | | - | - | - | | `webless:searchbar_click` | A user submits a search query | `query`, `sessionId`, `timeStamp`, `eventType` | | `webless:suggested_question_click` | A user clicks a suggested question | `query`, `sessionId`, `timeStamp`, `eventType` | | `webless:tile_click` | A user clicks a result tile | `query`, `sessionId`, `timeStamp`, `eventType` | | `webless:click_cta` | A user clicks the CTA button | `query`, `sessionId`, `timeStamp`, `eventType` | | Event | Fired when | Core fields | | - | - | - | | `webless:floating_button_visible` | The floating button enters the viewport | `sessionId`, `location`, `timeStamp`, `eventType` | | `webless:floating_button_click` | A user clicks the floating button | `sessionId`, `location`, `timeStamp`, `eventType` | ## Payload shape ```typescript theme={null} interface ClientEventPayload { eventType: string; timeStamp: number; sessionId: string; location?: "floating" | "nav"; query?: string; [key: string]: unknown; } ``` ## Example payloads ```json session_start.json theme={null} { "sessionId": "abc123-def456-ghi789", "timeStamp": 1703123456789, "eventType": "session_start" } ``` ```json searchbar_click.json theme={null} { "query": "What is artificial intelligence?", "sessionId": "abc123-def456-ghi789", "timeStamp": 1703123456789, "eventType": "searchbar_click" } ``` ```json floating_button_click.json theme={null} { "sessionId": "abc123-def456-ghi789", "location": "floating", "timeStamp": 1703123456789, "eventType": "floating_button_click" } ``` ## Performance and troubleshooting * Make sure Webless finished initializing before you add listeners. * Make sure your listener script appears after the Webless script. * Make sure no browser console errors stop later scripts from running. Debounce frequent events before forwarding them to your analytics service. ```javascript theme={null} const debounce = (fn, wait) => { let timeout; return (...args) => { clearTimeout(timeout); timeout = setTimeout(() => fn(...args), wait); }; }; const debouncedTrack = debounce((eventName, data) => { analytics.track(eventName, data); }, 1000); ``` # Export analytics data Source: https://docs.webless.ai/guides/export-data Retrieve a pre-signed download URL, wait for the file to be ready, and download the result. Data files expire after 7 days. Download them as soon as the pre-signed URL is ready. ## Export flow Send a `GET` request to `https://portal.webless.ai/query-data` with: * `company` * `start_date` * `end_date` * `x-api-key` in the request headers A successful request returns `202 Accepted` and a `presigned_url`. That URL becomes valid once the export file is written. Poll the `presigned_url` every 10 seconds with the `Range: bytes=0-0` header. Stop polling when the response returns `200 OK` or `206 Partial Content`. Reuse the same pre-signed URL to download the completed file. ## Request parameters | Parameter | Required | Format | Description | | - | - | - | - | | `company` | Yes | `string` | Your client code | | `start_date` | Yes | `YYYY-MM-DD` | Start of the date range, inclusive | | `end_date` | Yes | `YYYY-MM-DD` | End of the date range, inclusive | ## Example request ```http theme={null} GET https://portal.webless.ai/query-data?company=webless&start_date=2025-07-01&end_date=2025-07-03 x-api-key: YOUR_API_KEY ``` ## Example response ```json theme={null} { "presigned_url": "https://webless-client-data.s3.us-west-1.amazonaws.com/athena-results/.csv?X-Amz-..." } ``` ## Sample code ```python export_data.py theme={null} import time import requests API_KEY = "YOUR_API_KEY" API_URL = "https://portal.webless.ai/query-data" response = requests.get( API_URL, params={ "company": "webless", "start_date": "2025-07-01", "end_date": "2025-07-03", }, headers={"x-api-key": API_KEY}, timeout=30, ) response.raise_for_status() url = response.json()["presigned_url"] while True: probe = requests.get(url, headers={"Range": "bytes=0-0"}) if probe.status_code in (200, 206): break time.sleep(10) download = requests.get(url, stream=True) download.raise_for_status() with open("webless_results.csv", "wb") as outfile: for chunk in download.iter_content(8192): outfile.write(chunk) ``` ```javascript export-data.js theme={null} const axios = require("axios"); const fs = require("fs"); const API_URL = "https://portal.webless.ai/query-data"; (async () => { const trigger = await axios.get(API_URL, { params: { company: "webless", start_date: "2025-07-01", end_date: "2025-07-03" }, headers: { "x-api-key": "YOUR_API_KEY" } }); const url = trigger.data.presigned_url; while (true) { const probe = await axios.get(url, { headers: { Range: "bytes=0-0" }, validateStatus: (status) => [200, 206, 403, 404].includes(status) }); if ([200, 206].includes(probe.status)) { break; } await new Promise((resolve) => setTimeout(resolve, 10000)); } const response = await axios.get(url, { responseType: "stream" }); response.data.pipe(fs.createWriteStream("webless_results.csv")); })(); ``` ## Error handling | Status | Meaning | | - | - | | `400` | Missing or invalid parameter | | `403` | Invalid or missing API key | | `404` | Incorrect endpoint | | `429` | Rate limit exceeded | | `500` | Server error | For assistance, email [tech@webless.ai](mailto:tech@webless.ai). The source guide states a business-day response target of 4 hours. # Install the Webless tag Source: https://docs.webless.ai/guides/tag-installation Install the hosted Webless experience in your shared layout and verify it across your site. ## Standard install Before you start, make sure you have: * Access to your site's shared HTML template or layout file * Your Webless script URL (please make sure to use published version) ```html theme={null} ``` Add the hosted script at the start of `` tag. ```html layout.html theme={null} ``` After you add the script: 1. Save your template files. 2. Deploy your website changes. 3. Open a page on your website. Open your browser developer tools and confirm: * The Webless script loads successfully * No JavaScript errors appear in the console * Webless content renders inside the container ## Complete example ```html theme={null} Your website
...
...
``` ## Exclude specific pages Remove the script from any template where Webless should not render. ```html Pages without Webless theme={null} ``` ## Troubleshooting Check the basics first. * Verify that the script URL is correct. * Verify that the script tag is placed at the start of ``. * Verify that your domain has been authorized by Webless. ## Best practices * Load the script at the start of the body for faster rendering. * Use HTTPS for every hosted asset. * Re-test after major website releases or template changes. ## Need help? If you run into issues, contact the Webless team with: * Your website URL * The script URL you deployed * A screenshot of any console errors * Edit access to your website, if you can provide it # Webless documentation Source: https://docs.webless.ai/index Launch AI search, connected support, and data workflows across your website. Use this site to launch Webless on your website, connect downstream tools, and build custom search experiences when you need more control. # Turn your website into an answer surface Webless helps you add AI-powered search, guided discovery, analytics, and support handoff flows without rebuilding your full site experience. Install the standard Webless tag in your global template and verify it across your site. Coordinate REST calls and WebSocket streaming with a single request flow. Pull analytics data with the Data API and download the final result file. Route visitor conversations to Slack, Microsoft Teams, or Webex Contact Center. Flatten batched events into rows for enrichment and analysis. Configure Okta SAML for your Webless workspace. ## What Webless connects ```mermaid theme={null} flowchart LR site["Your website"] --> launch["Webless tag or custom frontend"] launch --> search["Search, answers, tiles, and CTAs"] search --> analytics["Webless analytics events"] analytics --> handoff["Human handoff"] handoff --> slack["Slack"] handoff --> teams["Microsoft Teams"] handoff --> webex["Webex Contact Center"] analytics --> clay["Clay webhook workflows"] analytics --> export["Data export API"] ``` ## Choose your path Start with the hosted tag if you want the fastest rollout. * Install the core experience with [Install the Webless tag](/guides/tag-installation). * Pass existing lead capture into Webless with [Embed forms in Webless](/guides/embedded-forms). * Track lifecycle events with [Listen to Webless analytics events](/guides/event-listeners). Use the backend APIs when you want to own the UI and orchestration. * Follow [Build a custom frontend](/guides/custom-frontend) for the complete request flow. * Track lifecycle events with [Listen to Webless analytics events](/guides/event-listeners). Connect Webless to the systems that help your team respond and report. * Route conversations to a person with [Set up human handoff](/integrations/human-handoff). * Push batched events into Clay with [Send events to Clay](/integrations/clay-webhooks). * Configure SAML with [Set up SAML SSO with Okta](/integrations/okta-saml). * Export historical data with [Export analytics data](/guides/export-data). Use the exact script URL, company identifier, tag IDs, provider IDs, and API keys that Webless provisions for your account. Several source guides use example values. # Send events to Clay Source: https://docs.webless.ai/integrations/clay-webhooks Create a Clay webhook table, flatten batched events, and enrich the results. Webless sends batched event data to Clay. Clay then lets you flatten each batch into rows and enrich the resulting records. ## Setup flow In Clay: * Click **New** * Choose **Workbook** * Search for **webhook** * Select the webhook table source Open **Edit source** or **Source**, find the webhook URL, and copy it. Send the URL to Webless so we can start posting batched events. After events arrive: * Open an event row * Find the `Data [...]` list in the cell details panel * Click **Take action on list** * Choose **Write each item to new row in other table** Use these settings for the best default result: * Destination: **New table** * Method: **Send row for each item in a list** * Enable **Auto-extract new columns** * Enable **Auto-map existing columns** if you use an existing table After the flattened table appears, add the fields you care about as dedicated columns. Common fields include: * Date * Page * Type * Query * Browser * Company * Summary * Location If you already know which attributes you want to report on, add those columns first so your enrichment workflow stays focused and easy to scan. # Set up human handoff Source: https://docs.webless.ai/integrations/human-handoff Connect Webless conversations to Slack, Microsoft Teams, or Webex Contact Center. Human handoff lets a visitor ask for a person from the Webless widget. The visitor stays in the widget. Your team replies from Slack, Microsoft Teams, or Webex Contact Center. Webless carries the transcript and page context into the provider, then sends human replies back to the same visitor conversation. ## How it works ```mermaid theme={null} flowchart LR visitor["Website visitor"] --> widget["Webless widget"] widget --> handoff["Webless handoff connection"] handoff --> slack["Slack"] handoff --> teams["Microsoft Teams"] handoff --> webex["Webex Contact Center"] slack --> widget teams --> widget webex --> widget ``` ## Before you start You need: * Admin access to the Webless Console workspace. * Permission to install or approve apps in the provider. * A destination for new handoffs: a Slack channel, Teams channel, or Webex Contact Center LiveChat target. * One test visitor conversation to verify the full round trip. | Provider | Destination | Admin usually needed | | - | - | - | | Slack | Workspace channel | Slack workspace admin or approved app installer | | Microsoft Teams | Team channel | Microsoft Teams tenant admin | | Webex Contact Center | LiveChat asset, domain, queue, or flow | Webex Contact Center admin | ## Configure Webless Open your site or index in Webless Console, then select **Human Handoff**. Turn on setup mode, choose where humans reply, and complete the provider steps. Human Handoff setup in Webless Console Turn on **Human Handoff** for the widget. Visitors only see the human option after a provider is connected. Select **Slack**, **Microsoft Teams**, or **Webex Contact Center**. Finish each setup step until Console shows the provider as connected. Start a widget conversation, ask for a human, reply from the provider, and confirm the visitor receives the reply in the widget. ## Slack Use Slack when your team handles visitor conversations from a workspace channel. ### What you need * A Slack workspace. * Permission to install the Webless Slack app. * A public channel, or a private channel where the Webless app has been invited. ### Setup In **Human Handoff**, choose **Slack** and click **Connect Slack**. Slack opens an authorization screen. Select the correct workspace and allow the Webless app. Pick the channel that should receive new handoff conversations. For private channels, invite the Webless app to the channel first. Console should show the Slack channel and mark the setup steps complete. Slack channel selected for Human Handoff If your workspace restricts app installs, use **Invite admin** from Console so the right Slack admin can finish authorization. ## Microsoft Teams Use Microsoft Teams when agents or teammates work from a team channel. A Teams tenant admin must install or approve the Webless app before the channel can receive handoff requests. ### What you need * Microsoft Teams tenant admin access. * The target team and channel. * The setup code shown in Webless Console. ### Setup In **Human Handoff**, choose **Microsoft Teams** and click **Connect Teams**. Webless generates a setup code and app package instructions. In Teams admin center, upload or approve **Webless Handoff**, then add it to the target team. In the target channel, open **Agents and bots**. You should see **Webless Handoff** in the app list. Webless Handoff installed in Microsoft Teams Agents and bots In the target channel, mention the bot and send: ```text theme={null} @Webless Handoff connect YOUR_SETUP_CODE ``` Replace `YOUR_SETUP_CODE` with the current code from Webless Console. Trigger a handoff from the widget and reply from Teams. The reply should appear in the visitor's Webless widget. The setup code connects one Webless handoff configuration to one Teams destination. Do not share it outside the admin or teammate completing setup. ## Webex Contact Center Use Webex Contact Center when routing, business hours, agent assignment, transfers, and closeout should stay in Webex. Webless does not replace Contact Center routing. Webless creates the bridge from the widget into Webex, then Webex owns the contact-center workflow. ### What you need * Webex Contact Center admin access. * Webex digital channels, Webex Connect, or Engage enabled for your tenant. * A LiveChat asset for the website. * A website domain added to that LiveChat asset. * A Contact Center queue, entry point, team, or flow target for Webless handoffs. * Agents who can accept and reply to the queued task. For production, your Webex admin authorizes the Webless service app. You do not need to create a separate Webex developer service app unless Webless support asks you to for a sandbox test. ### Setup In **Human Handoff**, choose **Webex Contact Center** and authorize the Webless service app from a Webex admin account. Confirm the Webex tenant and region that should receive handoffs. In Webex Contact Center, use the LiveChat asset that represents the website where the Webless widget runs. Add the exact website host to the LiveChat asset, for example `example.com` or `support.example.com`. Do not include `https://` or a path. Map the LiveChat asset to the queue, entry point, team, or flow that should receive Webless handoffs. Return to Console and select the Webex target. The setup steps should show as complete. The domain step is required. If the website domain is missing or does not match the visitor page, Webex can reject the conversation before an agent ever sees it. Webex Contact Center website domain settings The Webless setup screen separates what Webless needs from what should remain in Webex Contact Center. Webex handoff requirements in Webless Console ## Test checklist Before you turn handoff on for a production page, verify: * The visitor sees the human handoff option in the Webless widget. * The provider receives the handoff with transcript and page context. * A human reply from the provider appears back in the widget. * Follow-up visitor messages continue to reach the provider. * Closing or resolving the provider conversation behaves as expected. * The destination is owned by the right team. ## Troubleshooting Confirm handoff is enabled in Webless Console and that the provider connection is active. Confirm the Webless Slack app is installed in the workspace. For private channels, also confirm the app has been invited to the selected channel. Make sure you selected the correct workspace and that your Slack account can install apps. If app installs are restricted, invite a Slack workspace admin from Console. Ask a Teams admin to confirm **Webless Handoff** is uploaded, allowed, and added to the target team. Then open **Agents and bots** in the channel and search for **Webless Handoff**. Make sure the message mentions `@Webless Handoff` and includes the current setup code from Webless Console. Confirm the LiveChat asset has the exact website domain, the Contact Center target is mapped to a live queue or flow, and at least one agent can receive that task type. Open the LiveChat asset website settings and add the exact host where the Webless widget runs. Use `example.com`, not `https://example.com/page`. # Set up SAML SSO with Okta Source: https://docs.webless.ai/integrations/okta-saml Configure the Okta application and send the right metadata and group mappings to Webless. Webless handles the Firebase SAML configuration. Your team only needs to configure the Okta app and send the resulting IdP metadata and group mappings. ## Prerequisites * Okta admin access * Your SAML provider ID from Webless * The ACS URL from Webless ## Configure Okta Webless will provide: * Your SAML provider ID, such as `saml.okta.client1` * The ACS URL, such as `https://webless-frontend.firebaseapp.com/__/auth/handler` In Okta, create a new **SAML 2.0** app integration and use the provider ID in the app name so the app is easy to identify. Use these values exactly. | Field | Value | | - | - | | Single Sign On URL | `https://webless-frontend.firebaseapp.com/__/auth/handler` | | Recipient URL | `https://webless-frontend.firebaseapp.com/__/auth/handler` | | Audience Restriction | Your exact provider ID | | Name ID Format | `EmailAddress` | | Application username | `Email` | Add the following attribute statements: | Name | Format | Value | | - | - | - | | `email` | Unspecified | `user.email` | | `firstName` | Unspecified | `user.firstName` | | `lastName` | Unspecified | `user.lastName` | Then add a group attribute statement so Okta emits the full group list: | Name | Format | Filter | | - | - | - | | `groups` | Unspecified | `.*` | Create and assign your admin and user groups to the SAML app. Common examples include: * Admin groups: `admin`, `administrator`, `team_lead`, `managers` * User groups: `user`, `employee`, `staff`, `general` Send all of the following to Webless: * The Okta SSO URL * The Entity ID or Issuer * The full X.509 certificate * The list of admin group names * The list of user group names * Your email domain * Your authentication preferences for SAML, Google login, and password login After Webless enables your domain, sign in with SSO and verify the expected role assignment. * Admin users should receive `{domain}_admin` * Regular users should receive `{domain}_user` ## Troubleshooting * Verify the group attribute statement exists * Verify users are assigned to the correct Okta groups * Verify those groups are assigned to the SAML application * Verify the group names you gave Webless exactly match the group names in Okta * Verify the affected users belong to the expected groups The Audience URI in Okta must exactly match the provider ID Webless gave you, including case. # Set up Webex Contact Center Source: https://docs.webless.ai/integrations/webex-contact-center Authorize Webless Human Handoff and route Webless widget visitors to Webex Contact Center agents. Webless Human Handoff connects conversations from the Webless widget to Webex Contact Center. When a visitor asks for a human, Webless sends the conversation transcript and page context into Webex. Agents reply from Webex Contact Center, and the visitor keeps chatting in the same Webless widget. Webless creates the handoff and message bridge. Webex Contact Center still owns routing, queues, business hours, agent assignment, transfers, and closeout. ## Before you start You need: * An active Webless account with access to Webless Console. * Webex Contact Center with digital channels enabled. * A Webex Full Admin who can authorize the Webless service app. * Webex Contact Center admin access to configure LiveChat or Web Chat routing. * A website domain where the Webless widget is installed. * At least one Webex Contact Center agent who can accept and reply to chat tasks. If you do not have a Webless account yet, contact Webless from the [pricing page](https://www.webless.ai/pricing) or [request a demo](https://www.webless.ai/contact-us). The Webless team will help create your workspace and enable Human Handoff. ## Pricing and accounts Webless pricing is managed through Webless. See [Webless pricing](https://www.webless.ai/pricing) or contact your Webless account team. Webex Contact Center licensing, digital channel access, and any Webex usage costs are managed by Cisco/Webex. ## Setup overview ```mermaid theme={null} flowchart LR admin["Webex Full Admin"] --> authorize["Authorize Webless service app"] authorize --> webex["Configure Webex LiveChat target"] webex --> console["Map target in Webless Console"] console --> visitor["Visitor asks for a human"] visitor --> agent["Agent replies from Webex"] agent --> widget["Reply appears in Webless widget"] ``` ## Configure Webex Contact Center In Webex Contact Center, confirm your tenant has digital channels enabled and can create or use a LiveChat or Web Chat asset. Use the LiveChat asset that represents the website where the Webless widget runs. Add the exact website host to the LiveChat asset, for example `example.com` or `support.example.com`. Do not include `https://` or a path. Map the LiveChat asset to the queue, entry point, team, or flow that should receive Webless handoffs. Confirm at least one agent is assigned to the target queue or team and can accept chat tasks in Webex Contact Center Agent Desktop. The domain step is required. If the website domain is missing or does not match the visitor page, Webex can reject the conversation before an agent sees it. Webex Contact Center website domain settings ## Configure Webless In Webless Console, open the site or index that owns the widget, then select **Human Handoff**. Select **Webex Contact Center** as the provider. A Webex Full Admin authorizes the Webless service app. This allows Webless to create and manage the Contact Center handoff for your configured target. Confirm the Webex tenant and region that should receive handoffs. Choose the LiveChat, queue, entry point, or flow target that should receive Webless handoffs. Save the configuration, start a visitor conversation from the Webless widget, ask for a human, accept the task in Webex, and send a reply. The Webless setup screen separates what Webless needs from what remains managed inside Webex Contact Center. Webex handoff requirements in Webless Console ## What Webless requests from Webex Webless requests only the scopes needed to configure and operate the handoff bridge: | Scope | Purpose | | - | - | | `cjp:config` | Read and use Contact Center configuration needed for setup. | | `cjp:config_read` | List Contact Center targets available to the authorized tenant. | | `cjp:task_write` | Create and update Contact Center handoff tasks. | | `cjp:task_read` | Read task status needed to keep the visitor experience in sync. | | `spark:kms` | Support Webex platform authorization requirements for the service app. | ## Test checklist Before enabling this for a production page, confirm: * The visitor sees **Talk to a human** in the Webless widget. * Webless creates a Webex Contact Center task. * A Webex agent can accept the task. * The transcript and page context are visible to the agent. * A Webex agent reply appears back in the Webless widget. * Follow-up visitor messages continue to reach Webex. * Ending the conversation in Webex closes or resolves the handoff as expected. ## Troubleshooting Confirm the Webex service app was authorized by a Webex Full Admin and that the Webex tenant has Contact Center digital channels enabled. Confirm the LiveChat asset has the exact website domain, the target is mapped to a live queue or flow, and an agent is assigned and available for chat tasks. Check that the Webex queue or flow can route to an available agent. If no agent is available or the Webex flow rejects the task, update the Webex routing configuration and test again. Use a Webex Full Admin account for the same tenant that owns the Contact Center routing target. If the service app was changed after approval, reauthorize it in Webex Control Hub. ## Support For Webless setup help, contact [support@webless.ai](mailto:support@webless.ai). For Webex Contact Center licensing, entitlements, or tenant provisioning, contact your Cisco/Webex account team. # Quickstart Source: https://docs.webless.ai/quickstart Go live with Webless in 30 minutes using the smallest set of decisions ## Launch checklist Pick the smallest integration that fits your needs. Use the hosted Webless script if you want Webless to render the experience inside your site. Use the backend APIs if you want to build your own UI around search, summaries, suggestions, and CTAs. Open your website and confirm the Webless experience appears where you expect it. * Check that the script loads successfully. * Check that no console errors appear. Expand the rollout only after the core experience works. * Add [embedded forms](/guides/embedded-forms). * Send [events to Clay](/integrations/clay-webhooks). * Configure [Okta SAML](/integrations/okta-saml). * Set up [data export](/guides/export-data). Share the final information Webless needs to finish provisioning. * Your production website URL * Any Clay webhook URL * Your Okta metadata and group mappings * Any console errors or screenshots if something does not load ## Before you ask for help * Capture the full script URL you deployed. * Capture the page URL where the issue happens. * Capture a screenshot of the browser console if an error appears.