Custom chatbot for your website: build or buy
Should you build a custom AI chatbot or buy one? Compare cost, time to launch and upkeep before you commit developer hours to your store.
- Published
- Last updated
Buying usually makes more sense than building a custom chatbot for your website when your store needs product advice and buying in chat. Build when you need a workflow that existing tools can’t handle and have engineers to maintain it after launch.
The first working chat window is only part of the project. Live stock, customer permissions and failed payments need their own handling. An inexpensive model doesn’t remove that work.
How to create a chatbot for your website
To create a chatbot for your website, connect a language model to your catalogue and policies, then give it a storefront widget and controlled store actions. A model generates text. Your application decides which data it can read and which actions it can take.
An LLM agent combines a large language model with connected tools, conversation state and rules for taking actions. The LLM generates replies and can request a tool call. Your software executes the permitted operation and returns its result. State records details such as the selected product and the customer’s basket.
The distinction changes your build responsibility. Live availability needs a stock lookup. An order confirmation needs a successful store action, even when the model can generate convincing text for both. Catalogue retrieval supplies product facts, while authenticated store tools supply actions and enforce permissions.
A practical build has these parts:
- Choose a hosted model or an open model you run yourself.
- Make catalogue search return current products, prices and availability. Retrieve the relevant shipping or refund policy for each question.
- Build the chat widget, conversation history and recovery when a request fails.
- Connect basket actions and checkout. Add customer authentication before exposing private order information.
- Record tool calls, errors and usage. Give staff a way to take over and engineers a way to disable a faulty action.
For planning, allow four to eight developer weeks for a first version with catalogue answers and a basic basket connection. This is an illustrative allowance for an experienced developer, documented store APIs and a limited scope. It isn’t a delivery promise. Payment, returns or several storefronts need separate estimates.
A no-code prototype can answer uploaded policy documents sooner. That prototype hasn’t yet solved changing stock or shopper identity. Define the first release by what a customer can complete, such as finding an available item and adding the right variant to their basket.
Choose the chatbot UI and greeting
Chatbot design includes the launcher position, panel size and how product cards sit beside replies. Choose colours that match your store while keeping buttons and text easy to read. Cards need the product name, current price and the selected variant before a shopper adds anything.
A hosted chatbot builder usually exposes a defined set of branding and greeting controls. A custom build lets your developers change the layout and interaction, with your team maintaining those changes across screen sizes. For chatbot customisation, compare the controls you need with the work of owning the whole widget.
A homewares store could greet shoppers with, “Looking for something for your home? Tell me the room and your budget, and I’ll help you explore our range.”
A fashion store could use, “Need help choosing an outfit? Tell me the occasion and styles you like. I’m the store’s AI shopping assistant.” Keep the greeting clear about the assistant’s role and avoid promising a fit assessment.
Follow one shopper request through the system
In this illustrative build, a shopper asks, “Find a navy jacket under AUD $150 and add size M to my basket.” The storefront sends the message and its session identifier to your application.
- The application gives the model a catalogue-search tool with colour, size and maximum-price fields. Your search connection returns matching variants with current prices and stock.
- The model uses that result to explain the available option. If several products match, the widget asks the shopper to choose before adding anything.
- After the shopper chooses, a narrowly permitted basket tool receives the variant identifier and quantity. Your server validates the session and checks the price and availability again.
- The store returns a basket identifier and the added item, or an error. The agent reports that result instead of inventing a successful addition.
Your team supplies the search adapter and basket operation. It also stores the selected variant and basket against the correct session. OpenAI’s function calling guide describes the request, execution and result loop. Function calling alone supplies no store-specific basket connection.
For a first build, connect one approved catalogue and the policies staff already use. Start with read-only search, then add one basket action with server-enforced permissions. Run a private conversation through an unavailable item and a failed basket request. Show a clear route to staff when the answer or action cannot be completed. Broader order changes can wait until this limited flow works.
Keep credentials and private fields outside the model
A database connection starts in your server, where credentials stay in protected configuration. Give the model a narrow tool schema, such as an order-status lookup accepting an order identifier. Your server checks the signed-in customer and limits the query to their records.
Return only the fields needed for the reply, such as dispatch status and tracking information. Exclude payment details and staff notes. The model then explains that returned result. A remembered order number is conversation context, while a fresh authorised lookup supplies the current order state.
AI agent builders and AI agent platforms
An AI agent builder supplies tools for assembling the conversation, calling services and running the agent. An AI agent platform adds hosting and operational controls. Neither automatically understands your catalogue or your checkout rules.
A visual editor reduces the code needed to connect steps. A developer framework gives your team more control over state, permissions and unusual workflows. Both routes need store connections. A drag-and-drop box labelled “add to cart” still needs a real operation with a valid product variant and safe retries.
| Builder or platform | What it supplies | What your store must connect | How charges accumulate |
|---|---|---|---|
| OpenAI Agent Builder | A visual workflow canvas, preview runs and ChatKit embedding or exported code | Catalogue tools, customer identity and store actions | Model tokens and any billed tools or storage |
| Google’s agent platform, previously described as Vertex AI Agent Builder | Managed agent infrastructure and tools for developing and governing agents | Catalogue access, approved data sources and commerce actions | Model usage, runtime compute, storage and other selected services |
| Voiceflow | Hosted voice and chat agents, workflows and conversation monitoring | Store APIs, catalogue data and shopper permissions | Usage-based agency billing or a business quote |
| Botpress | Agent-building tools and customer conversations in a hosted workspace | Store-specific tools and authenticated actions | Conversation allowances, paid plans and extra conversation packs |
| n8n | Visual automation workflows with AI nodes, chat and service connections | A model, store credentials and workflows for each action | Cloud workflow executions, with model usage depending on the setup |
| Microsoft Copilot Studio | Agent authoring and connections through Microsoft’s platform | Store data, action permissions and a website channel | Copilot Credits through capacity or consumption billing |
OpenAI’s documentation places Agent Builder under legacy APIs. For a new custom build, its supported migration path belongs in the technical design. Google’s current product page calls the service Gemini platform. Older Vertex AI Agent Builder tutorials can use different product names and screens.
Free AI chatbot makers are useful for learning and small prototypes. Botpress’s Free plan includes 100 conversations with no top-ups or overages. Its paid plans use conversation allowances and extra packs. A conversation can contain several messages, so a 100-conversation allowance isn’t a 100-message allowance.
n8n’s Cloud trial includes 1,000 workflow executions. In a chat workflow that runs for each customer message, several executions can belong to one conversation. Its self-hosted Community Edition removes the Cloud subscription, but your hosting and model use still have costs. Voiceflow’s agency entry has a free trial and usage billing. A trial is different from an ongoing free plan.
Once you run several agents, an AI agent management platform helps staff see which version answered a question. Retained versions, answer review and per-agent usage monitoring make a faulty change easier to find. Different brands also need separate catalogue access and credentials, even when they share a model.
Separate free products from development tools
A free hosted agent runs on a supplier’s service, with its message or conversation allowance and supported connections. A free builder tier gives you authoring tools within a capped workspace. The Botpress allowance above is an example of the second route.
A developer framework supplies code libraries for your own application. It doesn’t include a free hosted shopper service. Your team pays for deployment and model use and maintains the store connections. Count messages, workflow executions and conversations separately when estimating usage.
Choose who runs the agent
OpenAI’s options include the Agents API and Agents SDK. The API manages the agent runtime and saved progress. The SDK runs in your application, giving your team control over deployment, storage and approvals. Either route needs the retailer’s permitted store tools.
Anthropic’s Claude Agent SDK provides an agent loop, sessions, tools and permission controls in a process you operate. Its Managed Agents offering supplies hosted orchestration. Calling Claude through a client SDK instead leaves your application responsible for the tool loop or its tool-runner configuration.
These products organise model requests and tool execution. Your store still decides which customer can read an order or change a basket. Keep those checks in the connected service, regardless of which provider runs the conversation.
Connect the store to a CRM
Consider an illustrative store that saves a shopper’s requested follow-up in its customer relationship management (CRM) system. A connection must expose the intended object and operation, then authenticate an authorised staff or service account.
| Connection route | Supported operation for this example | Authentication and retailer responsibility |
|---|---|---|
| Pre-built n8n HubSpot node | Create or update a contact, or create a ticket | Use its supported service-key or OAuth connection and restrict the workflow’s fields |
| HubSpot remote Model Context Protocol (MCP) server | Contact and deal operations among its supported CRM tools | OAuth with Proof Key for Code Exchange (PKCE), within the connected user’s permissions |
| Custom API tool | An application-defined contact update through the CRM API | Your server holds credentials, checks access and allows only approved fields |
The n8n HubSpot node documentation lists contacts, companies, deals, engagements and ticket operations. That list describes this connector, rather than every product labelled HubSpot integration.
HubSpot’s remote MCP documentation ties available tools to the account, subscription and user permissions. Its local Developer MCP server serves a separate development purpose. In the example, a user without contact-edit permission must receive a denied action, with no saved-contact claim in the shopper reply.
Monitor the result of each tool call as well as its text answer. Record a failed update, handover outcome and application version against the conversation. Track which fields the tool accessed, while keeping secrets out of logs. A convincing reply with a failed contact update is an operational failure.
Enterprise chatbots on a conversational AI platform
An enterprise chatbot on a conversational AI platform suits a retailer managing several brands, strict internal data rules or an established AI team. The reason to choose it is central control over many deployments.
That route can add enterprise licences and an integration partner to the budget. Your staff still need to own catalogue connections, security decisions and answer quality. Regional deployment, access controls and support commitments become contract requirements instead of assumptions about the model.
A store-level agent is easier to justify when one team needs shopping assistance on one site. A large platform becomes useful when shared governance saves more work than its administration creates.
Production decisions need named owners before deployment. Choose the hosting region and isolate each brand’s credentials, catalogue and customer records. Define permitted tools per agent, keep versions of settings and connections, and assign incident recovery to an accountable team.
Context engineering means selecting what the model receives for each request. For the navy-jacket example, supply matching catalogue variants, the relevant delivery policy, the selected size and the latest basket-tool result. Exclude another brand’s products and unrelated customer records. Store identity and tool permissions remain server checks, even when the conversation includes those details.
Choose an LLM for your store chatbot
An open source large language model (LLM) can generate the chatbot’s replies while your application retrieves catalogue data and executes approved actions. Downloadable model weights give you deployment control. They don’t supply a retail search engine or an order system.
For a retail build, shortlist models by the memory you can provide and the actions customers need. These are practical candidates, with different roles:
| Open model | Retail use to evaluate | Deployment consequence |
|---|---|---|
| Mistral Small 4 | Catalogue-grounded conversation, document questions and text or image inputs | Its 119 billion total parameters require substantial memory despite fewer active parameters per token |
| Ministral 3 8B or 14B Instruct | A smaller catalogue assistant or local development prototype | Lower memory demand than large models, with task-specific answer and tool checks still needed |
| Llama 3.2 3B Instruct | Local experiments with retrieval and simple conversation | A compact starting point, not evidence that it can handle every shopping or checkout task |
Mistral publishes Small 4 under Apache 2.0 and describes Ministral 3 models for local and edge use. Meta’s Llama 3.2 model card includes tool-use support and English among its supported languages. The best open source LLM for a store is the smallest model that meets that store’s answer and action requirements at peak traffic.
A GPT chatbot using OpenAI’s hosted models transfers model serving to the provider. An open-model build lets you choose where inference runs and how you change the model. Answer quality depends on the selected model, catalogue retrieval and permitted tools in either route. Neither a hosted brand name nor open weights guarantees accurate refund answers.
Your team owns open-model upgrades and compatibility checks. It also owns the serving configuration and the response when a deployment stops answering. Why AI invents answers explains the model problem in more depth.
Match the model to your store’s constraints
For a team that wants hosted tool calling without running model servers, GPT-6.1 Sol is a practical starting choice. Use its gpt-6.1-sol identifier with the Responses API for tool calls. Claude Sonnet 5.5, claude-sonnet-5-5, is another hosted candidate when your application already uses Anthropic’s tool interface.
For a narrow, high-volume lookup, start with GPT-6 Luna (gpt-6-luna) or Claude Haiku 5.5 (claude-haiku-5-5). Their published token rates are lower. Anthropic positions Haiku for latency-sensitive work. A quick lookup still waits for your catalogue tool and network, so model latency is only part of the response time.
When inference must stay on infrastructure your team controls, start with Ministral 3 8B for a smaller deployment. Mistral Small 4 suits teams able to provide substantially more serving memory. Mistral’s model pages list function calling for both ministral-8b-2512 and mistral-small-2603. Self-hosting also needs a serving engine that implements the model’s tool-call format.
| Candidate | Catalogue facts and grounding | Tool calls | Response time | Data control and running cost |
|---|---|---|---|---|
| GPT-6.1 Sol | Your retrieval supplies current facts and source identifiers | Responses API function calling | Network and reasoning effort affect completion time | Hosted inference, billed tokens |
| Claude Sonnet 5.5 | Your catalogue tool supplies stock and prices | Tool use through the chosen Claude platform | Anthropic lists it as faster than its larger reasoning models | Hosted inference on supported platforms, billed tokens |
| GPT-6 Luna or Claude Haiku 5.5 | Keep the task narrow and return structured catalogue fields | Supported tool interfaces still need server permission checks | Intended for lower-cost work, with Haiku positioned for low latency | Hosted inference with lower listed token rates |
| Ministral 3 8B Instruct | Your retrieval supplies facts and your application rejects unsupported values | Mistral documents function calling | Hardware, context length and queue size decide local delay | Local or hosted deployment, with server costs when self-run |
| Mistral Small 4 | Catalogue retrieval remains necessary despite a larger model | Mistral documents function calling | Serving capacity and reasoning settings affect delay | Open deployment with greater memory needs |
| Llama 3.2 3B Instruct | Useful for a small retrieval prototype | Model card documents tool use | Compact size helps local experimentation, without a live traffic guarantee | Local weights under Meta’s licence, plus your serving costs |
Product-fact fidelity means returning the exact variant, price and availability the store supplies. None of these model choices makes an old catalogue feed current. Keep those fields tied to the tool result and reject a conflicting generated value. For a store without a model-serving team, a hosted API removes that operational job. Choose an open model when control of inference justifies your serving costs.
Self-Hosted AI: the fullest build route
Self-hosted AI requires computers that can run the model and a team that keeps them available. Production infrastructure can mean GPU servers you own or dedicated cloud instances. Both need patches, monitoring and recovery procedures.
Keeping conversations on your own servers can justify this work when a documented requirement forbids external inference. The entire data path must meet that requirement. Calling a hosted model from your own web server still sends model input outside your infrastructure.
Ministral 3 3B or 8B and Llama 3.2 3B are sensible workstation candidates for testing. Actual memory needs depend on the weight format, context length and number of simultaneous requests. Quantisation reduces model memory by storing weights at lower precision. It can also change answer quality.
A developer workstation rarely makes a sound live service. It can sleep or lose connectivity, and shopper traffic competes with the developer’s own work. Production needs spare capacity and someone on call. Budget for a replacement machine or another instance before relying on one server.
Custom chatbot development costs
Custom chatbot development costs include engineering before launch, model or server use and ongoing maintenance. Compare the whole operating cost with buying, rather than treating the API bill as the project budget.
Here is an illustrative AUD budget, excluding GST. It assumes a developer cost of AUD $1,000 per day and 20 to 40 build days. These are planning inputs, not a quoted Australian market rate.
| Cost item | Calculation | Illustrative cost excluding GST |
|---|---|---|
| First build | 20 to 40 days at AUD $1,000 per day | AUD $20,000 to AUD $40,000 upfront |
| Maintenance allowance | Two developer days per month at AUD $1,000 per day | AUD $2,000 per month |
| GPT-6.1 Sol model use | 1,000 conversations under the token assumptions below | AUD $45 per month |
| Same model at higher volume | 10,000 equivalent conversations | AUD $450 per month |
| Same model at larger volume | 100,000 equivalent conversations | AUD $4,500 per month |
Search storage, hosting and payment-provider charges sit outside this example. Incident work also sits outside the two-day maintenance allowance. A new store API version or a broken catalogue feed can require work without any increase in conversation volume.
At 1,000 conversations, the example’s model bill is much smaller than its maintenance allowance. At 100,000, model selection and repeated context have a larger effect. Compare bought tools through AI chatbot pricing and usage costs when you need subscription structures.
Compare who maintains the service
An agency-run chatbot automation service can move engineering work out of your team. The contract still needs to say who owns each connection and who restores a failed shopper action.
| Responsibility | In-house build | Agency service | Packaged retail agent |
|---|---|---|---|
| Initial setup | Your engineers build and connect the system | A project or setup fee covers the agreed delivery scope | Integration and settings replace much of the custom work |
| Model usage | Your provider account or inference servers | Included allowance, usage pass-through or a separate bill, as contracted | The supplier’s session or token model |
| Store integration maintenance | Your team handles API changes and broken feeds | The maintenance agreement must assign these changes | Supplier maintains supported connections, retailer maintains its data and credentials |
| Failed shopper action | Your on-call engineer investigates and restores service | The support agreement names incident cover and response responsibility | Supplier handles its agent software, retailer handles store-side faults and staff handover |
| Future changes | Your team estimates and implements them | A retainer or new project scope covers the work | Use supported settings or request a supplier change |
For an agency quote, separate setup from recurring support and model consumption. Require a named incident owner and access to conversation and action logs. A low setup fee saves little if nobody has agreed to fix an expired store credential after launch.
ChatGPT API cost and other LLM costs
ChatGPT API cost is charged through the selected model’s input and output tokens. A token is a unit of text processed by the model. Catalogue snippets and repeated conversation history count as input, as well as the customer’s latest message.
OpenAI’s standard short-context pricing lists GPT-6.1 Sol at USD $2 per million input tokens and USD $10 per million output tokens. Anthropic lists Claude Sonnet 5.5 at the same base input and output rates. Their smaller options, GPT-6 Luna and Claude Haiku 5.5, list USD $0.10 input and USD $0.50 output for the applicable short prompts.
For this calculation, assume 10,000 input tokens and 1,000 output tokens across each complete shopper conversation. That makes 10 million input tokens and one million output tokens per 1,000 conversations. Use an illustrative conversion of USD $1 to AUD $1.50, excluding GST and currency fees.
| Model | AUD input per million tokens | AUD output per million tokens | AUD per 1,000 example conversations |
|---|---|---|---|
| GPT-6.1 Sol | AUD $3 | AUD $15 | AUD $45 |
| Claude Sonnet 5.5 | AUD $3 | AUD $15 | AUD $45 |
| GPT-6 Luna | AUD $0.15 | AUD $0.75 | AUD $2.25 |
| Claude Haiku 5.5 | AUD $0.15 | AUD $0.75 | AUD $2.25 |
The smaller models’ lower price doesn’t establish equivalent shopping performance. These estimates exclude caching, reasoning beyond the stated output, tool charges and any regional processing surcharge. Claude Haiku’s lower input rate applies to prompts up to 100,000 tokens. OpenAI’s listed short-context rates cover input up to 272,000 tokens.
A rented GPU changes the calculation to instance hours, memory and traffic capacity. In an illustrative rental budget of AUD $2 per hour, 730 hours costs AUD $1,460 before storage or staff. That is AUD $1.46 per conversation at 1,000 conversations, or about AUD $0.15 at 10,000. Both calculations assume the instance can serve that workload. The hourly amount is a budget assumption, not a provider quote.
Owned hardware adds its purchase cost, electricity and replacement capacity. If hardware costs AUD $9,000 and you spread it over 36 months, the hardware allowance is AUD $250 per month. You still pay for operations. Open weights remove a per-token provider charge only when you run inference yourself.
What buying gets you
Buying a retail agent gives you an existing shopping workflow and someone else maintaining its software. Compare what customers can complete, along with the tools your staff use to manage it.
shoppa is an AI shopping agent added to your site with two lines of code. Your customers find and compare products, add them to their basket and pay in the chat. They can track orders and start returns there too. Answers use your live catalogue and your own policy documents.
shoppa’s conversational search carries earlier choices forward when a customer asks for a different colour or a lower price. Its workspace includes catalogue import and sync, a private test agent and retained versions. You can publish a change for the next message and roll it back with one click. Conversation traces and shopping analytics help your team inspect the result.
Those are separate jobs your team otherwise has to build. A general agent builder can give engineers control over their own widget and model choice. Buying means working within the supplier’s supported controls and integration contracts. A retailer that needs arbitrary changes to the model-serving layer has a stronger reason to build.
shoppa has per-session and per-token pricing and a free trial. Get a quote for your store’s volume and requirements.
Build vs buy software decisions for retailers
Build versus buy AI depends on whether your store has the people to own a live AI system. A developer who can produce a chat demo isn’t automatically a team that can maintain shopper permissions and checkout failures.
| Decision factor | Buy a retail agent when | Build when |
|---|---|---|
| Budget | You need to limit upfront engineering and keep staff on the store | You have a funded build plus continuing operations |
| In-house skills | Staff can maintain product data and policies but don’t run model infrastructure | Engineers own integrations, security and AI evaluation |
| Time to launch | A supplier already handles your required shopping flow | Your schedule allows implementation and failure-path testing |
| Unusual requirements | Supported settings and store connections meet the need | A required action or data boundary needs custom behaviour |
| Operational ownership | You want a supplier maintaining the agent software | Your team can recover incidents and support future changes |
Building makes sense for an unusual ordering process, a mandatory self-hosting requirement or a wider platform your AI team already operates. Name a technical owner and provide operations cover before committing to it. Security and retail staff must also own the permissions and policies engineers implement.
For a store needing catalogue discovery and buying in chat, shoppa already handles that workflow. A custom build earns its cost when it solves a requirement that the existing workflow cannot meet.
Risks unique to a home-built chatbot
A home-built chatbot puts responsibility for wrong answers and failed actions on your own team. Set prices and refund eligibility through trusted store systems. Don’t let a generated answer create a discount or promise a refund.
Treat shopper messages and retrieved documents as untrusted instructions. A customer asking the agent to ignore its rules must not gain access to another customer’s order. Store tools must enforce identity and permissions themselves, even when the model requests a plausible action.
Checkout retries need special handling. If a payment response times out, the agent must establish whether the payment succeeded before attempting it again. Record an action identifier so one customer request can’t create duplicate orders.
Several cooperating LLM agents help when separate roles need separate tools. A catalogue adviser can read public product data while an order-support agent uses authenticated order access. One agent is simpler when the same permissions and workflow cover the whole conversation. Splitting an ordinary catalogue search adds handoffs without adding a permission boundary.
Your application must own shared context, including customer identity and the basket identifier. Give each agent only the tools its role needs. The component coordinating handoffs must detect a failed transfer and route the customer to staff. Store actions need shared action identifiers so two agents cannot repeat the same purchase.
The OpenAI Agents SDK’s handoff documentation explains how conversation history passes between agents and how input filters change it. Passing history doesn’t grant permission to read an order. Apply access checks at the tool, and keep one application owner responsible for recovery across the handoff.
Give out-of-hours failures an owner, an alert and a safe fallback to staff or ordinary checkout. The person on call needs a way to stop purchases without taking the whole site down. Use the chatbot testing checklist before launch, with wrong-price questions and failed-action recovery in the same acceptance workflow.
Give your store its own shopping agent
Customers ask in their own words. Your agent finds, compares and checks out from your catalogue, right on your site.