Tag 10,000 Feedback Lines for About $0.66

01 / Skip the vector store: price one request before you build

Most feedback tagging projects die before a single ticket is labeled. Someone proposes embeddings, a vector database and a fine-tuned classifier, the estimate lands in the hundreds of dollars, and the whole idea is shelved. A tiny budget forces a better first question: what is the smallest amount of text I can send to a cheap model and still get a tag I trust?

Start with arithmetic, not architecture. One piece of customer feedback is usually one to three sentences. At roughly 30 words that is about 40 tokens. A compact tagging instruction plus a short label list runs 120 to 180 tokens. The answer should be a single label, 5 to 10 tokens. All in, one line costs about 190 tokens.

That is your unit price, and everything else is multiplication. Ten thousand lines becomes 1.8 million input tokens and roughly 0.1 million output tokens. Multiply those totals by the per-million rates shown on the pricing page of the relay you choose. Worked example only: at $0.30 per million input and $1.20 per million output, 1.8 million input tokens is $0.54, 0.1 million output tokens is $0.12, and the entire corpus lands at $0.66. Your quoted rates will differ; the shape of the calculation will not.

Keep that number in mind when someone quotes you a monthly platform fee. CheapRelay fits this budget shape because it bills per real token with no monthly fee and no subscription, so a one-off tagging job costs what the tokens cost. Human review is still worth paying for, but only on a slice of the data, as I explain at the end.

02 / Seven labels, one sentence each, and a strict rule set

The label set is where beginners overspend. A taxonomy with 30 labels looks rigorous and produces mush: the model hesitates, the output lengthens, and you end up with inconsistent overlaps like billing, invoice, payment and refund all used for the same complaint. Keep the first pass to five to eight labels and define each one in a single sentence.

• ■ Complaint: a problem the customer wants fixed.
• ■ Question: the customer is asking for information, not a fix.
• ■ Praise: the customer is happy with something specific.
• ■ Feature request: the customer wants something the product does not do yet.
• ■ Billing: money, invoices, refunds, pricing or plan changes.
• ■ Churn risk: the customer says they may leave or cancel.
• ■ Other: anything that fits none of the above.

Two rules make this set usable. First, Other is mandatory, because forcing a label onto an ambiguous line is how you corrupt your own data. Second, decide single-label or multi-label before you write the prompt. For a first pass on 10,000 lines, single label is cheaper and far easier to audit; you can always run a second, narrower pass later on just the billing or churn slices. Put the labels in the order you expect to see them, most frequent first, and never rename a label halfway through a run, or you will end up stitching two incompatible datasets together.

03 / One prompt per batch that returns a label and nothing else

The request body should be plain text with four parts: the task, the label definitions, the tagging rules, and the numbered feedback lines. Ask for one line of output per input line in the form number, label. Nothing else. Every extra token of politeness, apology or explanation in the output is a token you pay for at the output rate, which is usually the higher of the two.

• ■ Set temperature low so repeated runs on the same text give the same tag.
• ■ Number the input lines explicitly, or the model will reorder them when a line is ambiguous.
• ■ State that the output must contain only the number and the label, with no markdown and no commentary.
• ■ Give two or three short worked examples only if your labels are genuinely confusing; each example adds tokens to every request.

Ask for a short confidence value after each label only if you plan to use it. It roughly doubles the output length, so on a 10,000 line job that is an extra 0.1 million output tokens, which in the arithmetic above adds about $0.12. That is a fair price for a triage signal, but it is not free, and if you will never open the confidence column, do not pay for it.

04 / The 10,000-line receipt: 1.8 million input tokens and counting

Now the receipt most beginners get wrong. Sending one feedback line per request means you pay for the instruction block 10,000 times. At 150 tokens of instruction per request that is 1.5 million input tokens spent on repeating yourself, against 0.4 million tokens of actual feedback. The instruction is 79 percent of the bill and none of it is new information.

Batch instead. Five lines per request turns 10,000 lines into 2,000 requests. The instruction becomes 150 tokens times 2,000 requests, or 0.3 million tokens. The feedback content stays at 0.4 million tokens. Total input drops from 1.8 million to about 0.7 million, and output stays near 0.1 million. At the same worked rates, that is $0.21 plus $0.12, so $0.33 for the corpus, roughly half of the naive run.

• ■ One line per request: 1.8 million input tokens, about $0.54 at the worked rate.
• ■ Five lines per request: 0.7 million input tokens, about $0.21 at the worked rate.
• ■ Twenty lines per request: fewer still, but longer outputs are harder to parse and a single malformed response wastes more work.

Five to ten lines per request is the practical range. Beyond that, one garbled response costs you a bigger re-run, and you lose the ability to spot-check a small batch before committing to the whole file.

05 / Prompt caching and batching cut the same bill twice

Caching attacks the repeated instruction from another direction. Put the static material first in every request: the task, the label definitions, the rules, the worked examples. Put the variable feedback lines after it. The relay then sees the same prefix over and over, and cached reads and writes are billed at their own per-token rates instead of full input rates. CheapRelay bills cache reads and writes per real token, so check those rates on the pricing page before assuming a win, and remember that the first request pays for the cache write.

Caching pays off most when the prefix is long and the requests are frequent. A 400 token taxonomy reused across 2,000 requests is a good candidate. A 60 token prompt run once is not. The same trick helps on the next batch: next month's feedback reuses the identical prefix, so the cache keeps working across runs instead of expiring with a one-off script.

Model choice is the last lever. Do the bulk pass on a cheap fast model, for example Claude Haiku 4.5 or DeepSeek V4 Flash, and reserve a stronger model for the slice the cheap one flagged. If you want to run this whole pipeline for a few dollars at a time, sign up at cheapapirelay.com and grab a key; one key reaches the whole model list and the same OpenAI-compatible routes work with the SDK you already use.

06 / Spend your review budget on the 5 percent you cannot trust

Automation without a check is just fast guessing. Hand-label a random sample of 200 lines yourself, run the pipeline on them, and compare. Report the result as a count, for example 187 of 200 correct, not as a vague mostly accurate. Then split those 13 misses into prompt problems, label definition problems, and genuinely ambiguous feedback. Only the first two are fixable, and fixing them is far cheaper than any model upgrade.

• ■ Send every Other label, every low-confidence tag and every line that mentions cancellation to a human queue.
• ■ Re-run only that queue on a stronger model, which is a few percent of the corpus rather than all of it.
• ■ Keep the hand-labeled 200 as a regression set, so a prompt change shows up as a count instead of a feeling.

That is the whole system: seven labels, five lines per request, a cached instruction prefix, a cheap model for the bulk pass, and a human looking at the small pile the model could not settle. On the worked rates here, a 10,000 line corpus costs under a dollar before review, and the review time goes to the handful of lines where a person actually changes the answer.