Detect outliers
Somewhere in a spreadsheet of ten thousand normal-looking rows sits the handful that are not normal at all — a mislabeled entry, a fraudulent claim, a product description copied from the wrong page. This endpoint reads every row, learns what typical looks like for that dataset, and hands back the ones that don't belong.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
The problem it solves, and for whom
Outliers are cheap to miss and expensive to leave unfound: a single fraudulent claim buried in ten thousand legitimate ones, a listing with the wrong category that quietly tanks search relevance, a support ticket that reads nothing like the others because it's actually a security report. Scanning by eye does not scale, and rule-based filters only catch the anomalies someone already thought to write a rule for. This is built for data teams, trust-and-safety reviewers, catalogue managers and analysts who need to find the exceptions without reading everything.
How it works, in practice
You submit a batch of text rows, and the task runs asynchronously, returning a task_id immediately. Behind the scenes, it measures how semantically close each row is to the rest of the dataset, and the rows that sit far from that center — statistically unusual, thematically off, or simply unlike anything else in the batch — come back flagged as outliers, delivered through your signed webhook or a 24-hour signed link. Nothing needs to be pre-labeled as 'normal' or 'abnormal' beforehand; the dataset defines its own baseline.
Why this differs from a simple keyword filter
A keyword blocklist only catches what you already anticipated; an anomaly detector catches what you didn't. The distinction matters because the most costly outliers are rarely the ones matching a known bad pattern — they're the ones nobody thought to look for. This approach, comparing each item's meaning against the collective norm of the dataset, has roots in classic statistical outlier detection but applied to unstructured text instead of numeric columns, which is what makes it useful for reviews, tickets, listings and free-form submissions rather than just spreadsheets of numbers.
Fitting it into a pipeline
Teams typically run this as a review gate: before a bulk product upload goes live, before a batch of claims gets auto-approved, before a week of survey responses gets archived. Because pricing is per request plus per 1000 rows, scanning a growing dataset for anomalies has a cost that scales predictably with volume, and a failed scan is retried automatically at no charge, so you're never billed for a task that didn't complete.
What it flags, and what it doesn't
It surfaces statistical and semantic exceptions — it does not claim a flagged row is fraudulent, wrong or malicious, only that it's unlike the rest of the batch, which is a signal for a human to review, not an automatic verdict. Treat the output as a shortlist worth a closer look, not a final judgment.
What you can do with it
Fraud claim screening
An insurer scans a week of submitted claims and gets back the small subset that reads differently from the rest, prioritizing those for manual review instead of spot-checking at random.
Catalogue quality control
A marketplace runs outlier detection before publishing a bulk product upload, catching the handful of listings with a mismatched category or a copy-pasted description before shoppers ever see them.
Support ticket escalation
A helpdesk flags tickets that don't resemble typical requests, surfacing the rare security report or legal threat buried among routine password-reset tickets.
Survey data cleaning
A research team scans open-text survey responses for the ones that look like spam, gibberish or off-topic answers before including the dataset in an analysis.
FAQ
How does the anomaly detection API find outliers in text?
It compares the meaning of each row against the rest of the dataset and flags the ones that are statistically or thematically far from the norm.
Do I need to label examples of anomalies first?
No. The dataset defines its own baseline of what's typical, so you don't need to pre-label 'normal' or 'abnormal' rows beforehand.
Is there a free tier for search.outliers?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
What does anomaly detection cost for a large dataset?
It's $0.002 per request plus $0.002 per 1000 rows, making the cost of scanning a large batch predictable in advance.
Does flagging a row mean it's fraudulent or wrong?
No. A flagged row is simply unlike the rest of the batch; it's a signal worth human review, not an automatic verdict of fraud or error.
How many outliers will it return?
The number depends on how uniform your dataset is — a very consistent dataset yields few flags, a noisy one yields more.
How do I get the results?
The call returns a task_id right away, and flagged rows are delivered via signed webhook or a signed link valid for 24 hours.
Can I run this on bulk datasets?
Yes, it's built for bulk scanning — submit thousands of rows in one batch, with pricing scaling per 1000 rows processed.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/search/outliers \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/search/outliers", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/search/outliers",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/search/outliers", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/search/outliers", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "search.outliers",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_chunks | 10000 |
max_tokens | 20000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |