What Cohere actually changed
Cohere’s own deprecation page records two separate events, and teams often merge them into one. The first is the endpoint: “After January 31st, 2025, usage of Classify endpoint via the default Embed models will be deprecated.” The same page lists /v1/classify among the deprecated endpoints effective 15 September 2025.
The second event is the one that removes the escape hatch. Fine-tuning for command-light, command, command-r, classify and rerank was retired effective 15 September 2025, and Cohere states that previously fine-tuned models will no longer be accessible. The older advice — keep the endpoint and run it on a model you tuned yourself — no longer describes a service you can rely on.
What the page does not publish is a final shutdown date for every existing call. That means an integration can still answer today and still be the wrong place to build tomorrow. Treat the endpoint as a system you are leaving, not as a supported option with an unknown end date. The rest of this guide assumes you need a replacement you can own, not a stay of execution.
What a replacement has to keep
A classifier call looks small from the outside: send text, receive a label. The parts that take work to replace are the assumptions around it. Before comparing vendors, write down which of these your current pipeline actually depends on, because a replacement that drops one of them is not a migration, it is a new project.
- The label set and its definitions. If the old model learned labels from examples, you need those examples, not just the label names.
- What comes back besides the label: a score, a rank, a probability, or nothing. A downstream threshold only works if the replacement returns a number with the same meaning.
- The review path. A low-confidence answer has to be routable to a person; silently mapping it to “other” hides the uncertainty instead of handling it.
- Batch behaviour. One row in, one row out, with retries that do not charge completed rows twice.
- Language coverage. A model that performs well in English does not automatically perform the same way in every language your customers write in.
- The data path. Who processes the text, what is stored, and how long it is kept are procurement questions as much as engineering ones.
- The unit you are billed in. Tokens, requests and credits are not interchangeable, and the cheapest unit is not always the cheapest accepted decision.
Three realistic replacements, side by side
The table compares the interfaces as their vendors document them on 2026-10-21. It is not a quality ranking: none of these vendors publishes an accuracy figure for your data, and a public benchmark would not transfer to your labels anyway. The practical difference is what each one makes explicit.
| Option | What you send | What you get back | Your own labels | Confidence | Billing unit |
|---|---|---|---|---|---|
| Cohere Chat | A prompt and a response schema | Generated JSON that follows the schema | Yes, described in the prompt or schema | Not a dedicated field; a score would be generated text | Tokens, e.g. Command $1.00 in / $2.00 out per 1M |
| OpenAI Moderation API | Text, and images with the omni model | 13 fixed harm categories plus category_scores | No, the category list is fixed | category_scores from 0 to 1 | Free |
| Jev API Pro | Text, instructions, 2–12 labels, a threshold | One label, confidence when supplied, a review flag | Yes, the labels are part of the request | A confidence value or null, never invented | Prepaid credits, one per successful request |
Option 1: Cohere Chat with a structured response
Staying with Cohere is a legitimate choice when the surrounding workflow already uses its models and you need generated text as well as a label. The classification becomes a prompt that lists the allowed labels and asks for a JSON object, and your application validates the object before acting on it.
The trade-off is that the allowed answers live in the prompt and in your validator rather than in the request contract. A model can return a label outside your list, a plausible-looking score that is not calibrated, or an explanation where you expected one field. You can constrain the shape with a schema; you still have to test whether the chosen label is right. If your team already has that validation layer and wants one vendor, this is the smallest organisational change. Cohere’s published token prices let you estimate the cost, but the estimate depends on prompt length and output length, both of which you control.
Option 2: OpenAI Moderation API
The Moderation API is free, which makes it the first thing many teams try after a classifier is retired. It returns 13 harm categories with category_scores between 0 and 1, and the omni-moderation-latest model accepts text and images; audio is not classified. That is a strong fit for one job: screening content against a fixed harm taxonomy at no marginal cost.
It is not a general replacement for a custom classifier. The category list is not yours, so a pipeline that routed invoices, refunds or product feedback by its own labels cannot express those labels here. Several categories are text-only, and an image-only request scores zero for them. OpenAI’s own guidance also warns that custom policies built on category_scores may need recalibration over time. Use it where its taxonomy matches your policy, and keep a separate, owned classifier for business labels.
Option 3: Jev API Pro
Jev is a hosted typed-decision API for the narrower case: you have a list of answers and you want one of them back, with a review flag when the model is unsure. The labels, the instructions and the threshold are fields in the request, so an answer outside your list is a contract violation rather than a parsing surprise. A choice question takes 2 to 12 labels, a score question takes 2 to 7 ordered levels, and one request can ask up to four questions for one credit.
The response contains the chosen label, a confidence value when the provider returns one, and a needsReview flag. Confidence may be null; it is never filled in with a default, because an invented number would defeat the review rule that depends on it. This is a smaller product than a chat model on purpose: it does not draft replies, summarise documents or explain its answer. If those are part of the job, run them as a separate step after the decision.
curl https://jevapi.pro/api/v1/decisions \
-H "Authorization: Bearer $JEV_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: ticket-88213-v1" \
-d '{
"text": "The export has been empty since Tuesday and I need it for a board pack.",
"instructions": "Choose the team that owns the fix. Escalate data loss in a paid workspace.",
"labels": ["billing", "data_export", "account_access", "other"],
"threshold": 0.85
}'A migration you can test before production moves
The safest migration is boring: keep the old path alive while a candidate runs beside it on the same records, and only switch when the comparison supports it. The steps below work for any of the three options above, not just Jev.
- Export a labelled sample: several hundred real records if you have them, including the ambiguous ones and the cases closest to an action boundary.
- Record the expected answer before you look at any candidate output, so the test cannot be graded to fit the result.
- Send the same records to the candidate. Keep the source text free of unnecessary personal data and credentials.
- Compare agreement, the review rate at your threshold, and the cost of each kind of mistake. A false “billing” route is cheaper than a missed security report; weight them separately.
- Run a small shadow period where the candidate writes a suggestion but a person still decides. Measure how often the suggestion is accepted before you automate the step.
curl https://jevapi.pro/api/v1/decisions \
-H "Authorization: Bearer $JEV_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: ticket-88213-v1" \
-d '{
"text": "The export has been empty since Tuesday and I need it for a board pack.",
"instructions": "Choose the team that owns the fix. Escalate data loss in a paid workspace.",
"labels": ["billing", "data_export", "account_access", "other"],
"threshold": 0.85
}'Cost per accepted decision, not cost per call
The three options are billed in units that cannot be compared directly. OpenAI Moderation is free. Cohere bills tokens: at the prices on its pricing page, 500 input tokens and 50 output tokens on Command cost 500 × $1.00/1M + 50 × $2.00/1M = $0.0006. That is arithmetic from published rates, not a quote, and it excludes retries, failed generations and the engineering time spent validating output.
Jev bills prepaid credits. Launch is $99 for 10,000 credits, which is $0.0099 per successful request; Growth is $299 for 50,000 ($0.00598) and Scale $699 for 150,000 ($0.00466). A one-off pack is $19 for 1,000 credits ($0.019). On raw unit price Jev is more expensive than a short Cohere call. The comparison only becomes meaningful when you add what the credit buys: the review flag, stored request history, API keys, and a request contract that rejects answers outside your labels. If your volume is very high and your labels are simple, a token-priced chat call can be cheaper; if your team would otherwise build and maintain the validation and review layer, the credit price is the cost of not building it.
When switching is the wrong move
Do not migrate if the old endpoint still answers and your only plan is to keep it running unchanged. That is a decision to defer, and it is reasonable while you measure the volume and the risk. Write down the date you will revisit it, because the retirement of fine-tuning has already removed the fallback that made deferral comfortable.
Do not migrate to a fixed-category moderation API if your labels describe business processes rather than harm. Do not migrate to a chat model if your application cannot validate generated output and you have no one to own that validation. And do not migrate to a decision API if you need a written explanation with every answer; that is a different product, and adding a generated rationale afterwards is a separate step with its own review.
Frequently asked questions
Is the Cohere Classify endpoint shut down?
Cohere’s deprecation page records that Classify through the default Embed models was deprecated after 31 January 2025, and lists /v1/classify as a deprecated endpoint effective 15 September 2025. The same page does not announce a final shutdown date, so an existing call may still answer. What is settled is the direction: new work should not be built on that endpoint.
Can I keep using my fine-tuned Classify model?
No. Cohere retired fine-tuning for command-light, command, command-r, classify and rerank effective 15 September 2025, and states that previously fine-tuned models will no longer be accessible. A migration plan cannot assume the old model is still callable.
What is the closest replacement for a Cohere Classify call?
There are two honest answers. If you need generated text as well as a label, Cohere Chat with a structured response keeps you on one vendor. If your application only needs one label from a list you define, plus a review flag, a bounded decision API such as Jev is a smaller contract: the allowed answers are part of the request instead of something you validate after generation.
Does Jev return a calibrated probability?
It returns a confidence value when the upstream provider supplies one, and null when it does not. That number is the model’s own output, not an accuracy measured on your traffic, so it should not be read as a probability of being correct. A missing value is sent to review rather than replaced with a default.
How many labels can one Jev request use?
A choice question accepts 2 to 12 labels, and one request can ask up to four typed questions; a score question accepts 2 to 7 ordered levels. One successful request costs one credit whether it asks one question or four.
How is Jev priced compared with Cohere?
Jev sells prepaid access with credits: Launch is $99 for 10,000 credits, Growth $299 for 50,000 and Scale $699 for 150,000 per 30 days, with quarterly and annual periods and a $19 one-off 1,000-credit pack. Cohere prices tokens per model, for example Command at $1.00 input and $2.00 output per million tokens. The two units are not interchangeable, so compare the cost of an accepted decision on your own volume.
Can I test a replacement without moving production traffic?
Yes. Export a labelled sample of real cases, send the same records to the candidate and to your current path, and compare agreement, review rate and the cost of each wrong answer before switching. Jev’s browser batch page accepts CSV, TXT or JSONL and keeps one result per row, so the evaluation does not need an API key first.