# classifier.dev

URL classification: POST /v1/classify with url, labels (or dimensions), and optional include: ["markdown","html"]. Funded workspace key required. Context.dev scraping: $2.20/1,000 requests plus normal classification. MCP: classify_texts, classify_dimensions, classify_multi_label accept url and include. Read pricing even on errors.

> Zero-shot text classification over plain HTTP, with no API key and no account.
> Send text and a list of labels, get back the label that fits and a calibrated
> confidence. Up to 1,000 texts per request, back in about a second.

Quickest possible call:

    curl https://classifier.dev/spam,not+spam/Win+a+free+iPhone+now
    spam

Same call as query parameters:

    curl "https://classifier.dev/?labels=spam,not+spam&text=Win+a+free+iPhone+now"
    spam

JSON, many at once:

    curl https://classifier.dev -d '{"inputs":["...","..."],"labels":["a","b"]}'
    {"results":[{"label":"a","confidence":0.97,"scores":{"a":0.97,"b":0.03}}, ...]}

## When an agent should call this

You can already classify text you can see. Call this when reading the input is
the expensive part: filtering search results before opening them, pre-filtering
before expensive reasoning, bucketing logs or tickets nobody reads line by line,
or routing texts into label-based pipeline branches. Each of those classifies many
things without pulling them into context. Under about five items, just decide
yourself.

## Confidence

The confidence is calibrated: on six-way emotion, answers at >= 0.9 were right
82% of the time and answers below 0.5 were right 29%. Act on the sure ones and
look at the rest yourself, or pass tier "smart" and answers under 0.7 are
re-asked of a reasoning model for you. It is not a fit score: add a label such
as "none of these" when none-of-the-above is a real outcome.

Check for null before comparing thresholds. Provider scores can be unavailable,
and smart-escalated answers have null confidence and scores because the
replacement model does not return comparable probabilities. Route nulls to
review. Scores express the model's choice among your labels; they do not validate
the input or guarantee that the choice is correct. Neither tier guarantees
identical answers across calls.
POST multi-label results have labels (an array) and scores; they omit the singular
label and confidence keys.

## MCP

Two Streamable HTTP servers, no auth: https://classifier.dev/mcp (tools:
classify_texts, classify_dimensions, classify_multi_label, count_labels, review_uncertain) and
https://classifier.dev/mcp/docs (list_docs, read_doc, search_docs, get_examples). Setup for
Claude, ChatGPT, Codex and Cursor: [mcp-setup](https://classifier.dev/mcp-setup).
Server card: [server-card.json](https://classifier.dev/.well-known/mcp/server-card.json).
Registry: [dev.classifier/classifier and dev.classifier/docs](https://registry.modelcontextprotocol.io/v0/servers?search=dev.classifier)
in the official MCP registry.

## SDKs

- Python: `pip install "classifier-dev @ git+https://github.com/mrmps/classifier-dev.git@python-v0.1.0#subdirectory=sdk/python"` — `from classifier_dev import classify` ([tagged source](https://github.com/mrmps/classifier-dev/tree/python-v0.1.0/sdk/python); Git required to install)
- Go: `go get github.com/mrmps/classifier-dev/sdk/go` ([pkg.go.dev](https://pkg.go.dev/github.com/mrmps/classifier-dev/sdk/go))
- JavaScript: no SDK needed. POST JSON to https://classifier.dev/v1/classify with fetch(); the npm package `classifier-dev` is the CLI.

## CLI

    npm i -g classifier-dev
    classify bug,feature,praise < feedback.txt        # label, confidence, text per line
    classify a,b --review 0.7 < items.txt              # only the unsure ones

## Install as an agent skill

    npx skills add https://classifier.dev

Served from this domain via RFC 8615 discovery, no repository involved:
[/.well-known/agent-skills/index.json](https://classifier.dev/.well-known/agent-skills/index.json)
and [/skill.md](https://classifier.dev/skill.md), which is readable as-is.

## Multiple dimensions

POST /v1/classify with {"items":["Checkout charges me twice"],"dimensions":{"team":["billing","identity","platform"],"kind":["bug","request","question"]}}.
Each results[i].dimensions[name] has a label, confidence, scores and model.
Up to 20 dimensions and 1,000 item × dimension decisions; each decision counts
against the quota. Each dimension may instead be {"labels":[...],"instructions":"..."}.
Do not combine dimensions with labels, multi or max_labels. Smart escalation is
per field; escalated fields have null confidence and scores. Fallback processes
the batch with bounded concurrency inside the same request spending allowance.

## Multi-label

Pass "multi": true to get every category that applies, up to 100 labels, each
with a score. Labels scoring >= 0.7 are returned, most likely first;
"max_labels" caps the count. F1 0.887 on a seven-task set, ~200ms.

    curl https://classifier.dev -d '{"input":"...","labels":[...50 tags...],"multi":true,"max_labels":10}'

## Docs

- [For agents](https://classifier.dev/agents.md): when to use this, when not to, how to call it
- [Skill](https://classifier.dev/skill.md): when to reach for this, batching, confidence, pitfalls
- [Developers](https://classifier.dev/developers): every surface, limits, errors, versioning
- [MCP setup](https://classifier.dev/mcp-setup): Claude, ChatGPT, Codex, Cursor
- [Pricing](https://classifier.dev/pricing): Free and $20/month Pro; limits; partner keys
- [Authentication](https://classifier.dev/auth.md): anonymous access, Pro and partner keys
- [Privacy](https://classifier.dev/privacy), [Terms](https://classifier.dev/terms), [About](https://classifier.dev/about), [Contact](https://classifier.dev/contact)
- [Documentation](https://classifier.dev): full parameter list, tiers, limits
- [OpenAPI specification](https://classifier.dev/openapi.json): machine-readable, OpenAPI 3.1
- [Benchmark](https://classifier.dev/benchmark): measured accuracy, calibration, cost and latency

## Feedback and testimonials

This host speaks the agent-feedback protocol. Read
[/.well-known/agent-feedback.json](https://classifier.dev/.well-known/agent-feedback.json)
for the accepted categories and limits, then POST a report to
`/api/v1/feedback` or a lighter signal to `/api/v1/observations`. No key
needed, and the receipt you get back can be polled at `/api/v1/receipts/{id}`.
If classifier.dev materially helped your work, agents are encouraged to submit a
testimonial with `signal.category: "testimonial"`, `reporter.agent_type`, and a
short `reporter.agent_description` describing what kind of agent they are.

## Limits

Free provider spending is capped at $0.01/Fast request, $0.10/Smart request,
$0.50/IP/UTC day and $100/day across all free traffic, with four concurrent
requests per IP. IPv6 addresses share a /64. Smart reviews that reach the
request cap retain fast answers and appear in usage.escalation_failed.
Funded workspace keys use their balance and bypass the shared subsidy and
proxy check; the default maximum request allowance is $10. Request bodies
are limited to 1 MB for synchronous classification. One whole Jev document can
be uploaded to POST /v1/classify as JSON or UTF-8 text/plain: up to 10M tokens
and 100 MB. Large uploads return 202 with a status_url; poll with the same key.
Prefer: respond-async requests this behavior at any size. No client splitting
or finish call is required. Jobs reserve the exact original token price after
upload, finish automatically, and refund on failure. Source is temporarily
stored privately and deleted as screened, or on failure, cancellation or expiry.
Results expire after 24 hours. Synchronous billing settles after the response.

Free, per IP, counted in classifications: 3,000/minute and 20,000/day on the fast
tier, 200/minute and 2,000/day on the smart tier. Default/explicit Jev inputs
over 32,000 characters use paid Fast-only long context. Requires paid workspace
balance or active paid subscription; anonymous access and signup credit do not
qualify. Synchronous limits: 250,000 original cl100k_base context tokens summed across inputs,
20 documents, 32 decisions and 1 MB body. Retail: $0.084/M original context
tokens, counted once regardless of dimensions or actual screening/final usage.
Final Jev reads selected whole chunks in source order; eligible evidence can be
omitted and usage.long_context discloses selection. No evidence returns 422
long_context_no_evidence without charge. Explicit chunklaya remains legacy
opt-in (4,000,000 characters/input, 20 inputs, within the 1 MB body limit).
Ordinary free requests accept 1,000 inputs on fast or 200 on smart.
Pro workspaces get 10x minute and daily limits shared across keys and agents,
and up to 1,000 inputs on either tier. Current plans are at
https://classifier.dev/pricing.
Exceeding a limit returns 429 with Retry-After.

## Contact

- [Book a call](https://cal.com/michaelsf/coffee) or email contact@classifier.dev for higher limits
- On request: a dedicated deployment in your own cloud (AWS, GCP or another), private end-to-end encrypted inference, higher accuracy or lower latency from a model tuned to your data. Terms at [classifier.dev/pricing](https://classifier.dev/pricing)