See the platform work before you sign in.
Every block on this page is the interface a customer uses. Ask the chatbot a question, index a document, open the widget, route a lead, run a sync. None of it is a screenshot.
Answers from your material, with the passage they came from.
Hybrid retrieval fuses keyword and vector search, the answer streams, and every citation is filtered down to the chunks the answer actually used. Ask one of these.
Two rules are locked on
The model answers only from the retrieved material, and a credential is removed from the chunks before they reach it rather than being forbidden in the prompt.
See guardrailsFour steps between a file and an answer.
Pick a source and run it. Extraction handles PDF, DOCX, XLSX, PPTX, HTML, Markdown and JSON; chunks are hash-diffed, so an unchanged passage is never embedded twice.
A document is refused if the bytes in storage do not match the row that describes them, and the failure is what makes the next sync heal it.
One 38 KB script, six surfaces, your colours.
Preact inside a shadow root, so nothing on the host page can reach it and nothing it does can restyle the page. Change the surface and the accent below.
Allowed domains
Wildcards supported. An origin that is not on the list is refused before the model is called.
Page context
The widget sends the page it is on and updates it on SPA navigation, so the answer knows where the visitor is.
Speaks first, once
A proactive message can open the conversation one time per visit. Your own icon replaces the mark.
The form is the conversation. Each answer is saved as it arrives.
The model does not hold the answers in its head and write them at the end. Every reply writes its field immediately and returns what is still outstanding, so a visitor who leaves halfway still leaves a record.
Twenty field types, each with its own options list, edited on a page of their own rather than in a dialog. The same validation runs in the widget and on the server.
A captured lead lands in the tool your team already opens.
Both ends of the mapping are editable: the questions the chosen widget's form actually asks on one side, the destination's own fields on the other. Pick a destination.
Verified live against 22 spaces and 4,959 lists. A dropdown value is sent as its option id, never as a string.
Send sample lead invents a lead and runs it through the same mapping a real one uses. Failures are retried and can be resent from the dispatch log.
What was asked, what answered it, and what nothing answered.
Rollups run nightly, and the retention window purges what is past it. Pick a range.
Ten ways in, sixteen ways out.
Sources feed the knowledge base; destinations receive what the conversation produced. Click one to see exactly what moves.
- Realtime on publish, plus a resumable bulk sync with a retry queue.
- The plugin injects the widget, so no theme file is edited.
- Plan usage and an event log live on the plugin's own settings screen.
Downloadable from Integrations, on every plan including Starter.
Work that runs without anybody opening the app.
Two chains do most of it: a schedule that keeps the knowledge current, and a route that carries a captured lead out. Both record every run.
A run that gets stuck cannot silence the next one: the sync log shows source, connection, trigger, duration and every counter, and a manual sync is always available.
Ten percent of every payment, for as long as they keep paying.
The link is a twelve-character code on an address that never says affiliate, referral, promotion or discount. It reads like any other link to the product, which is the point.
app.welcomeai.dev/billing/c/8fk29dl4mq7vRotating the code does not break what you earned
A referral points at the link row, not at the string, so a link you publish and later rotate keeps paying on the workspaces it already brought in.
The access you can be given
A workspace can hand a referrer the referral role: admin's day-to-day work, minus billing, minus renaming the workspace, and minus the API key that would read the whole workspace from outside it.
If it is not a connector yet, it is a POST.
Send content into a knowledge base from your own systems. Each document is matched by the id you send, so posting the same one twice updates it instead of duplicating it. Every key is scoped to what it may touch and capped by a daily budget, so a runaway script cannot spend the month.
- Five outgoing events, in a signed envelope carrying t= and v1=.
- Six retries over about 36 hours, then auto-disabled after 20 consecutive failures.
- A revoked key stops verifying by construction: revoking takes the hash with it.
curl -X POST https://app.welcomeai.dev/api/v1/ingest \
-H "Authorization: Bearer wai_live_********" \
-H "Content-Type: application/json" \
-d '{
"kb_id": "kb_7f2a9c4b1d3e",
"external_id": "faq-seats",
"title": "Adding a seat mid-cycle",
"url": "https://acme.com/help/seats",
"content_md": "A seat added mid-cycle is prorated for the days that remain."
}'BODY='{"external_id":"faq-seats","title":"Adding a seat mid-cycle","content_md":"Prorated for the days that remain."}'
TS=$(date +%s)
SIG=$(printf '%s.%s' "$TS" "$BODY" | openssl dgst -sha256 -hmac "$WELCOMEAI_WEBHOOK_SECRET" | sed 's/^.* //')
curl -X POST 'https://app.welcomeai.dev/api/v1/kb/kb_7f2a9c4b1d3e/sync?t=whsec_********' \
-H "Content-Type: application/json" \
-H "X-WelcomeAI-Timestamp: $TS" \
-H "X-WelcomeAI-Signature: sha256=$SIG" \
-d "$BODY"One account rule, and two things it cannot switch off.
Settings used to be copied into every knowledge base and every form. Now the account holds the rule, and a base or a form replaces it wholesale rather than merging with it.
The account rule. Everything inherits this unless it declares its own.
Answer only from the material
Locked onWhen nothing retrieved answers the question, the assistant says so.
Never repeat a credential
Locked onEnforced by removing it from the retrieved chunks rather than by asking the model not to.
Real matches on this corpus score between 0.33 and 0.58. The default was once 0.78, which meant the vector half of hybrid retrieval never returned anything and the product was doing keyword search while paying for embeddings.
Six things that are enforced, and how you can tell.
Every page says it takes security seriously, which is why nobody reads that sentence. These are the rules the code holds, each with the mechanism that fails loudly when one stops being true.
One workspace cannot read another
Every row that belongs to a workspace carries its workspace id, and data access goes through helpers that take the workspace as an argument, so a query that forgets it does not compile.
Nothing runs without an authorisation decision
Every server action and route handler has to reach one, and every mutation has to record who did it. A deliberately public endpoint is listed by name, with its reason written next to it.
Your credentials are encrypted, and nobody reads them back
Every secret you give us is encrypted with AES-256-GCM before storage and is never returned to a browser. Not to you either: to change one you replace it. Keys we issue are stored only as a hash and shown once.
A way in that cannot be phished
A passkey is held by your device and bound to this domain, so a copy of our sign-in page on an address that only resembles ours has nothing to ask for. Your password keeps working beside it.
The widget answers your domain and no other
A widget session token is bound to the origin that asked for it, and the domains allowed to ask are yours to list. Copying the snippet onto another site does not bring the knowledge base with it.
We only fetch public addresses
The crawler, adding a document by URL, link checks and webhooks all go through one rule: the machine at the other end has to be a public one, judged on the address the connection actually reaches.
Twenty-four jobs, and the part of the product that does each one.
Each one has a page of its own saying what to feed it, what changes, and which integrations belong with it.