A Support Bot for a One-Person Shop: Built From Your Own Policy Pages, and the Rate Limits and Spend Caps That Decide Who Gets Answered

A one-person shop gets the same forty questions a week: where is my order, do you ship to Ireland, can I return this, does it run small. This page builds a bot that answers them from your own policy pages, in the smallest way that works for one person, then reads the two numbers on each provider's page that decide whether the bot is still answering at the end of a busy month: the price per million tokens, and the ceiling on how much you may send or spend. Every step comes from the providers' own documentation; the honest parts about what does not exist come from there too.

What you hand over

To yourself, first: a desk assistant you paste a customer's message into and get a correct, cited answer out of, in your shop's words, from your shipping, returns, sizing and payment pages, with a plain fallback when the answer is not in them. To your customers, second, if you or a developer can host a small server: the same bot in a chat widget on the site. And, in a folder of your own, the policy files and the system prompt that make either one, so the whole thing can be rebuilt on another provider in an hour.

Step one: the policies as files

The bot is only as good as the pages you give it, so write those before you open any console. One file per topic, in plain words, covering the questions you actually get: shipping countries and times, returns and who pays postage, sizing, payment methods, order changes. OpenAI's file search accepts .pdf, .docx, .md, .html, .txt and .json among others; Gemini's File Search takes documents up to 100 MB each and a total store of 1 GB on the Free tier or 10 GB on Tier 1, and stores them free of charge. OpenAI stores the first 1 GB free and charges $0.10 per GB per day after. For a shop's policies, storage on either is zero.

Path A: in a browser, an afternoon

Open Google AI Studio. The Playground opens with a new chat prompt; click Run settings in the top-right corner and paste your policy files into the System Instructions field, with one line above them: answer only from the pages below, in the shop's voice, and if the answer is not in them say so and offer the shop's email. Then be the customer. Type the ten questions you get most, in the way customers type them, and read the answers against the pages. Where it invents, tighten the line; where it is right but cold, add a sentence about tone. The quickstart's own worked example is exactly this shape, a customer service chatbot that only talks about a company's product, built by editing the system instructions and rerunning.

What you have at the end of the afternoon is a desk assistant: paste the customer's message, copy the answer, send it from your own inbox. For a shop with forty questions a week that is most of the value of a bot, and it needed no code and no server. When it is right, Get code turns the same prompt into the API call for Path B. One caution before any real customer message goes through it: the pricing page says Free tier content is used to improve Google's products and Paid tier content is not, and the rate-limits page says linking a billing account moves the project to Tier 1 typically instantly. Link it first.

Path B: one call, with the files attached

The API route is the same prompt with the policy files attached in one of three documented ways.

OpenAI's is the file search tool in the Responses API. The guide's sequence is: upload each file, create a vector store, add the files to it, poll until each file's status is completed, then send the customer's message with the file_search tool and the vector store id in the tools list. The response holds a file_search_call item and a message with file citations, so the answer points at the page it came from. It is a hosted tool: the model decides when to search and OpenAI runs the search. Pricing has two lines beyond tokens: $2.50 per thousand tool calls, and the storage above.

Anthropic's is prompt caching. Put the policy text in the system prompt and mark it with a cache_control block of type ephemeral. The cache lives 5 minutes and is refreshed at no additional cost every time it is used, so a bot in steady conversation keeps it warm; a 1-hour cache is available at extra cost. The price table is the point: on Claude Haiku 4.5, base input is $1 per million tokens, writing the cache is $1.25, and reading it is $0.10; on Sonnet 5, $2, $2.50 and $0.20; on Opus 5, $5, $6.25 and $0.50. Your 5,000 tokens of policy are read at a tenth of the price on every exchange after the first.

Gemini's is File Search: create a File Search store, upload the files to it, and pass the store as a tool on each request. The page says file storage and query-time embeddings are free, that you pay for embeddings once at indexing and for retrieved document tokens as regular context, and that File Search cannot be combined with Google Search grounding in the same request.

One exchange, then the month

Count one real exchange: a customer message of about 300 tokens, your policies at about 5,000, an answer of about 200. On gpt-4o-mini, $0.15 in and $0.60 out per million, with the policies pasted into the prompt, that is a tenth of a cent, and a thousand exchanges are about a dollar; with the policies retrieved through file search instead, the prompt is smaller but the tool adds $2.50 per thousand calls. On Claude Haiku 4.5 without caching, 5,300 input tokens at $1 and 200 output tokens at $5 come to about six dollars a thousand; with the policies cached at $0.10, under two dollars. The AI job cost calculator has the token prices for every model on this page.

Then the line that trips people. Anthropic's page prints a minimum cacheable prompt length: 4,096 tokens for Haiku 4.5, 1,024 for Sonnet 5, 512 for Opus 5. A 3,000-token policy set on Haiku 4.5 is processed without caching, and no error is returned; the only sign is that cache_creation_input_tokens and cache_read_input_tokens both read zero. If your policies are short, pad them past the floor with the FAQ, or pick the model whose floor you clear.

The ceiling comes before the price

Every provider on this page publishes a ceiling above the price, and the chart above is OpenAI's. OpenAI's usage tiers: the Free tier, for users in an allowed geography, allows $100 of usage a month; Tier 1, reached with $5 paid, also $100; Tier 2 at $50 paid, $500; Tier 3 at $100 paid, $1,000; Tier 4 at $250 paid, $5,000; Tier 5 at $1,000 paid, $200,000. Underneath sit rate limits in requests and tokens per minute and per day, hit on whichever comes first, and the file search tool has its own, 100 requests a minute on Tier 1. Anthropic's spend caps by tier are $500 a month on Start, $1,000 on Build and $200,000 on Scale, with a token bucket that may enforce 60 requests a minute as one a second, per model. Gemini's Tier 1 needs a linked billing account, caps the account at $250 and spend at $10 per rolling 10 minutes; Tier 2 needs $100 paid plus 3 days and caps at $2,000. None of this touches a thousand exchanges; a product that goes viral on a Saturday can touch all of it.

Write the fallback before the cap

The making step most guides skip is what the bot says when the provider says no. Anthropic's page is exact: once the spend cap is reached, API usage pauses until 00:00 UTC on the first day of the next month unless a higher limit is requested, and every request returns HTTP 429 with the error code enforced_spend_limit_reached and no retry-after header, so retries fail until access resumes. Gemini's spend limit returns 429 RESOURCE_EXHAUSTED and clears on its rolling 10-minute window. So the bot's code, or your desk routine, must treat a 429 as a message, not a crash: one plain sentence, the shop's email, and a note to you. Anything that is not a live reply, the week's ticket summary, tagging, translating the FAQ, goes through OpenAI's Batch API, 50% cheaper on a separate pool of higher limits and done within 24 hours, so it never competes with the customer at the counter.

Where the bot lives

Here is the part to read before promising a widget. A bot on the website needs a server between the page and the provider, because the key cannot sit in the page. OpenAI's ChatKit is the embeddable chat for that, and its guide says your server must create a ChatKit session with a unique user identifier for each end user and hand the client secret to the widget. Its no-code companion, Agent Builder, the visual canvas that hosted workflows so ChatKit could point at them, is being deprecated and is scheduled to shut down on November 30, 2026, with new work directed to the custom server integration. So the honest options are two: a developer who hosts a small server for ChatKit or an equivalent, or the desk assistant from Path A, which answers the same questions through you. For forty questions a week, the second is often the right size.

What ends it

The bot is a single point of failure, and both agreements say how it can fail. Anthropic may suspend all access over a suspected Usage Policy breach and disclaims liability for any loss of data or profits that suspension causes. OpenAI may limit or suspend access if required by law or if the customer breaches the agreement or OpenAI Policies, without prior notice where necessary. The defence is the folder from the first section: the policy files and the system prompt are yours, and the data page reads what each provider keeps of the conversations. If the shop lives on Shopify, the plan is $25 a month paid monthly or 19 US$ a month paid yearly, and the bot's dollar sits under it.

What to do today

Write the shipping and returns pages as two short files. Paste them into Google AI Studio's System Instructions with the answer-only-from-these line, link a billing account, and ask it your ten questions. If it answers eight correctly, you have a desk assistant before dinner; the drafting page shows how the same system prompt becomes one API call, and the caching floor and the 429 fallback above are the two things to write down before it ever talks to a customer unsupervised.