HTTP status code lookup
An HTTP status code is compact, but the number alone is not always memorable. This lookup turns a code from 100 through 599 into its standard reason phrase and broad response category: informational, success, redirect, client error, or server error.
Run — free
It is useful while reading logs, debugging an integration, reviewing monitoring alerts, or explaining an API response. The result is deterministic, requires no network request, and clearly marks valid but unassigned codes instead of inventing a meaning.
Read a response code without breaking your workflow
HTTP responses place a three-digit status code at the start of the protocol’s response metadata. When that code appears in a log line, webhook delivery report, browser console, reverse-proxy trace, or API client exception, this lookup provides the human-readable label immediately. Enter one integer between 100 and 599. The result repeats the normalized code, supplies its registered or commonly standardized reason phrase, and identifies the category represented by the first digit. For example, 404 resolves to “Not Found” and the client error category, while 503 resolves to “Service Unavailable” and the server error category. This is a reference lookup, not an HTTP request: it does not contact the affected site, test whether an endpoint is healthy, or infer why a particular response occurred. That separation makes the output stable and safe to use in documentation, support tools, command-line scripts, log enrichment pipelines, and educational interfaces where the code’s conventional meaning is needed without adding network latency or exposing a private URL.
Understand categories and unassigned values
The five categories come directly from the hundreds digit. Codes from 100 through 199 are informational and describe an interim response. Codes from 200 through 299 indicate success. Codes from 300 through 399 concern redirection or another step needed to complete retrieval. Codes from 400 through 499 describe a client error, meaning the request cannot be fulfilled in its current form. Codes from 500 through 599 describe a server error, meaning the server failed while handling an apparently valid request. Not every number inside those ranges has an assigned reason phrase. An in-range value such as 299 is structurally a success code, but it has no standard phrase in the lookup table, so the result says “Unassigned” while still reporting the success category. This distinction matters: rejecting every unfamiliar code would confuse a valid HTTP extension range with malformed input, while inventing a phrase would make logs and documentation misleading. Only values outside 100 through 599, fractional numbers, and nonnumeric input are treated as invalid.
Use the result correctly in debugging and automation
A reason phrase is a concise label, not a diagnosis. If an API returns 401 Unauthorized, the phrase identifies the response semantics, but the actual remedy may involve a missing bearer token, an expired session, a signature mismatch, or a policy decision described in the response body. Likewise, 500 Internal Server Error identifies a server-side failure without revealing which component failed. Use this lookup as the first interpretation step, then inspect response headers, body content, request method, retry guidance, and service-specific documentation. In automation, the category is often more durable than the phrase: a monitoring rule can group all 500–599 responses as server errors, while an interface can display the specific phrase for people. Software should still branch on the numeric code when exact behavior matters. The API costs $0.002 per request and returns small JSON fields suitable for direct storage or display. Because the calculation is local and deterministic, the same input always produces the same output and no remote system can alter the answer.
What you can do with it
Interpret application logs
Turn isolated numeric response codes into readable phrases and categories while investigating requests.
Enrich monitoring alerts
Add a stable reason phrase and error category to alerts before they reach an on-call engineer.
Explain API behavior
Give developers and support teams a concise conventional meaning for a response code in documentation or tickets.
FAQ
What input does the lookup accept?
Provide one whole HTTP status code from 100 through 599. Values outside that range and non-integers return an invalid input error.
What happens when a code is in range but has no standard phrase?
The reason phrase is returned as “Unassigned,” and the category is still derived from the first digit.
Does this tool send a request to a website?
No. It performs a deterministic local lookup and does not contact any URL or external service.
Can the reason phrase explain the root cause of an error?
No. It states the conventional meaning of the code. Use the response body, headers, logs, and service documentation to diagnose the specific cause.
How much does the API lookup cost?
Each API request costs $0.002. The browser version runs locally for free.
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/http-status-lookup \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"code":404}'const res = await fetch("https://api.kit.forhosting.com/web/http-status-lookup", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"code": 404
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/http-status-lookup",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"code": 404
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/http-status-lookup", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"code":404}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"code":404}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/http-status-lookup", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"code": 404
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.http_status_lookup",
"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
timeout_sec | 30 |
max_crawl_pages | 25 |
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. |