Bulk Classify

Classify at scale without reading

classifier.dev assigns text to your categories. No key, no signup, no SDK. One HTTP call takes up to a thousand texts at a time and comes back in about a second, each with a confidence you can act on.

When this is worth a network call

You are a language model. You can already classify any text you can see, for free. The question is whether you want this text in your context at all.

Reach for this when reading the input is the expensive part:

• Filtering before reading. You have 40 search snippets and want the 6 worth opening. Classifying them yourself means pulling all 40 into context first, which is the cost you were trying to avoid. One call returns 40 labels and you read only the survivors.
• Cascade pre-filter. Cheaply drop the obvious no's, then spend real reasoning on what is left.
• Streams you would never read line by line. Log lines, error buckets, inbound tickets, changed files in a large diff, ten thousand URLs' titles.
• Label-based routing. Use the fast tier to route texts into your categories. Model updates, fallback, and smart reasoning can change answers; neither tier guarantees identical results across calls.

Do not bother when you have a handful of items already in context, or the judgement needs reasoning about things the text does not state. Under about five items you have already paid the context cost, so just decide yourself.

Quickstart

One text, bare label back:

curl "https://classifier.dev/relevant,not+relevant/Redis+beats+Postgres+for+queues"
relevant

The same call as query parameters, when code is building the URL:

curl "https://classifier.dev/?labels=relevant,not+relevant&text=Redis+beats+Postgres+for+queues"
relevant

Many texts in one call. This is the path that matters:

curl https://classifier.dev -d '{
  "labels": ["relevant", "not relevant"],
  "inputs": ["first snippet", "second snippet", "third snippet"]
}'

Returns results in input order. Single-label results have {label, confidence, scores}. Confidence and scores can be null; check before comparing a threshold. Multi-label results use {labels: [...], scores: {...}} instead. Up to 1,000 texts per call; 400 news headlines measured at 650ms end to end. For more, fan out calls in parallel; the limit is 3,000 classifications a minute. Each result also names the model that answered it. At the batch level, modelsUsed lists every serving model and model is mixed when more than one model answered the batch.

From a shell

When the text is already in files, or the answer feeds another command, the CLI saves you writing the batching and the JSON:

npm i -g classifier-dev

classify bug,feature,praise < feedback.txt          # label<TAB>confidence<TAB>text, input order
classify relevant,"not relevant" --review 0.7 < snippets.txt   # only the unsure ones
classify db,web,ml --count < titles.txt             # a histogram instead of rows
classify a,b --json < items.txt | jq -c 'select(.confidence == null or .confidence < 0.8)'

It batches a thousand inputs per request, four requests at a time, and streams rows as they land, so | head on a large file returns at once. Retries 429 and 5xx with backoff. --help has the rest.

Reach for the HTTP API instead when the text is already in memory, when you need the full score map per item, or when you are inside a language runtime where one fetch is simpler than a subprocess.

Parameters

Long context requires a workspace key backed by paid balance or an active paid subscription; signup credit and anonymous access do not qualify. Use POST with at most 250,000 original cl100k_base context tokens across inputs, 20 documents, 32 decisions and a 1 MB body. Price: $0.084/M original context tokens counted once across inputs, independent of dimensions and actual screening/final usage. Final Jev reads selected whole chunks in source order; eligible evidence may be omitted when the budget fills. usage.long_context discloses selection. No evidence returns 422 long_context_no_evidence without charge. Explicit model: "chunklaya" remains a separate legacy opt-in.

On GET every option goes in the query string, whichever form carries the labels and text; the two forms mix (/a,b?text=...). If a GET is malformed the error comes with usage: and try: — try is a URL built from what you sent that would have worked. Follow it rather than re-reading the docs.

Labels are read semantically, so name them in words: urgent bug classifies better than p0.

Confidence you can act on

The model is a decision model, not an LLM prompted to classify: it returns a calibrated probability for every label. Measured on 400 six-way emotion items, answers at confidence ≥ 0.9 were right 82% of the time; answers below 0.5 were right 29% of the time. So:

for text, r in zip(texts, results):
    if r["confidence"] is not None and r["confidence"] >= 0.8:
        act(r["label"])
    else:
        look_yourself(text)      # or send it through tier "smart"

tier: "smart" does that routing server-side: every single-label answer under 0.7 confidence is re-asked of a fast reasoning model and replaced, marked escalated: true, with usage.escalated telling you how many. Measured: four-way news 87.5% → 90.0% by re-asking 12% of items. It costs a few seconds per escalated item, so a batch on smart is slower in proportion to how uncertain it is. Escalated answers have confidence: null, scores: null, and unscored: the reasoning model does not return comparable probabilities. These answers belong in review when your workflow requires a confidence gate.