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.

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:

  1. Choose a hosted model or an open model you run yourself.
  2. Make catalogue search return current products, prices and availability. Retrieve the relevant shipping or refund policy for each question.
  3. Build the chat widget, conversation history and recovery when a request fails.
  4. Connect basket actions and checkout. Add customer authentication before exposing private order information.
  5. 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.

  1. 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.
  2. The model uses that result to explain the available option. If several products match, the widget asks the shopper to choose before adding anything.
  3. 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.
  4. 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 platformWhat it suppliesWhat your store must connectHow charges accumulate
OpenAI Agent BuilderA visual workflow canvas, preview runs and ChatKit embedding or exported codeCatalogue tools, customer identity and store actionsModel tokens and any billed tools or storage
Google’s agent platform, previously described as Vertex AI Agent BuilderManaged agent infrastructure and tools for developing and governing agentsCatalogue access, approved data sources and commerce actionsModel usage, runtime compute, storage and other selected services
VoiceflowHosted voice and chat agents, workflows and conversation monitoringStore APIs, catalogue data and shopper permissionsUsage-based agency billing or a business quote
BotpressAgent-building tools and customer conversations in a hosted workspaceStore-specific tools and authenticated actionsConversation allowances, paid plans and extra conversation packs
n8nVisual automation workflows with AI nodes, chat and service connectionsA model, store credentials and workflows for each actionCloud workflow executions, with model usage depending on the setup
Microsoft Copilot StudioAgent authoring and connections through Microsoft’s platformStore data, action permissions and a website channelCopilot 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 routeSupported operation for this exampleAuthentication and retailer responsibility
Pre-built n8n HubSpot nodeCreate or update a contact, or create a ticketUse its supported service-key or OAuth connection and restrict the workflow’s fields
HubSpot remote Model Context Protocol (MCP) serverContact and deal operations among its supported CRM toolsOAuth with Proof Key for Code Exchange (PKCE), within the connected user’s permissions
Custom API toolAn application-defined contact update through the CRM APIYour 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 modelRetail use to evaluateDeployment consequence
Mistral Small 4Catalogue-grounded conversation, document questions and text or image inputsIts 119 billion total parameters require substantial memory despite fewer active parameters per token
Ministral 3 8B or 14B InstructA smaller catalogue assistant or local development prototypeLower memory demand than large models, with task-specific answer and tool checks still needed
Llama 3.2 3B InstructLocal experiments with retrieval and simple conversationA 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.

CandidateCatalogue facts and groundingTool callsResponse timeData control and running cost
GPT-6.1 SolYour retrieval supplies current facts and source identifiersResponses API function callingNetwork and reasoning effort affect completion timeHosted inference, billed tokens
Claude Sonnet 5.5Your catalogue tool supplies stock and pricesTool use through the chosen Claude platformAnthropic lists it as faster than its larger reasoning modelsHosted inference on supported platforms, billed tokens
GPT-6 Luna or Claude Haiku 5.5Keep the task narrow and return structured catalogue fieldsSupported tool interfaces still need server permission checksIntended for lower-cost work, with Haiku positioned for low latencyHosted inference with lower listed token rates
Ministral 3 8B InstructYour retrieval supplies facts and your application rejects unsupported valuesMistral documents function callingHardware, context length and queue size decide local delayLocal or hosted deployment, with server costs when self-run
Mistral Small 4Catalogue retrieval remains necessary despite a larger modelMistral documents function callingServing capacity and reasoning settings affect delayOpen deployment with greater memory needs
Llama 3.2 3B InstructUseful for a small retrieval prototypeModel card documents tool useCompact size helps local experimentation, without a live traffic guaranteeLocal 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 itemCalculationIllustrative cost excluding GST
First build20 to 40 days at AUD $1,000 per dayAUD $20,000 to AUD $40,000 upfront
Maintenance allowanceTwo developer days per month at AUD $1,000 per dayAUD $2,000 per month
GPT-6.1 Sol model use1,000 conversations under the token assumptions belowAUD $45 per month
Same model at higher volume10,000 equivalent conversationsAUD $450 per month
Same model at larger volume100,000 equivalent conversationsAUD $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.

ResponsibilityIn-house buildAgency servicePackaged retail agent
Initial setupYour engineers build and connect the systemA project or setup fee covers the agreed delivery scopeIntegration and settings replace much of the custom work
Model usageYour provider account or inference serversIncluded allowance, usage pass-through or a separate bill, as contractedThe supplier’s session or token model
Store integration maintenanceYour team handles API changes and broken feedsThe maintenance agreement must assign these changesSupplier maintains supported connections, retailer maintains its data and credentials
Failed shopper actionYour on-call engineer investigates and restores serviceThe support agreement names incident cover and response responsibilitySupplier handles its agent software, retailer handles store-side faults and staff handover
Future changesYour team estimates and implements themA retainer or new project scope covers the workUse 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.

ModelAUD input per million tokensAUD output per million tokensAUD per 1,000 example conversations
GPT-6.1 SolAUD $3AUD $15AUD $45
Claude Sonnet 5.5AUD $3AUD $15AUD $45
GPT-6 LunaAUD $0.15AUD $0.75AUD $2.25
Claude Haiku 5.5AUD $0.15AUD $0.75AUD $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 factorBuy a retail agent whenBuild when
BudgetYou need to limit upfront engineering and keep staff on the storeYou have a funded build plus continuing operations
In-house skillsStaff can maintain product data and policies but don’t run model infrastructureEngineers own integrations, security and AI evaluation
Time to launchA supplier already handles your required shopping flowYour schedule allows implementation and failure-path testing
Unusual requirementsSupported settings and store connections meet the needA required action or data boundary needs custom behaviour
Operational ownershipYou want a supplier maintaining the agent softwareYour 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.

See it in actionFree trial · Simple setup