ForHosting KIT · Developer Utilities

List HTTP status codes by category and reason phrase

Choose an HTTP response category and get a complete, ordered list of its assigned standard status codes and reason phrases.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

The five supported categories are informational, success, redirect, client error, and server error, corresponding to the 1xx through 5xx classes. The result also identifies the numeric range and number of entries, making it useful for documentation, tests, developer tools, and quick protocol reference without sending a network request or inspecting a live server.

Choose one of the five HTTP response classes

HTTP status codes are grouped by their first digit. Informational responses occupy the 100–199 range and describe interim progress before a final response. Success responses use 200–299 and indicate that a request was received, understood, or completed in the way described by the particular code. Redirect responses use 300–399 for resource selection, changed locations, cache validation, and related routing decisions. Client errors use 400–499 when the request cannot be fulfilled because of its syntax, credentials, preconditions, target, rate, or another client-side condition. Server errors use 500–599 when the server or an intermediary cannot complete an apparently valid request. Supply one category name and the result returns its canonical name, numeric range, entry count, and an ascending `statuses` array. Category matching ignores letter case, surrounding whitespace, hyphens, and underscores, so `Client Error`, `client-error`, and `client_error` select the same class. Other labels are rejected clearly instead of being guessed.

Read codes and reason phrases accurately

Every array entry contains a numeric `code` and its standardized `reason_phrase`. The phrase is a concise conventional label, not a complete explanation of when a response should be generated. For example, 404 Not Found identifies the result, while the applicable HTTP specification defines cache behavior, method interactions, and representation semantics. Modern registry wording is used where older references may differ: 413 is Content Too Large and 422 is Unprocessable Content. Code 418 is included with the registry label Unused; the familiar teapot phrase comes from an earlier experimental specification and should not be treated as its current core registry title. Unassigned gaps are intentionally absent. That is why a category does not necessarily contain every integer within its numeric range. The list is sorted numerically, allowing callers to render tables directly, compare approved codes in a test, or construct a selector without another sorting pass. Reason phrases are descriptive metadata: HTTP/2 and HTTP/3 do not carry a reason-phrase field on the wire, and clients should make decisions from the numeric status code.

Use the result in documentation and validation

This capability works well when a tool needs a bounded reference set rather than details about one live response. A documentation generator can request each category and build consistent tables. A test harness can verify that an application emits a registered code in the expected class, while still applying its own rules about which specific responses an endpoint permits. An API explorer can populate a grouped menu with the returned reason phrases, and teaching material can contrast interim, successful, redirect, client-error, and server-error outcomes. The computation is a fixed in-memory lookup: it performs no network request, reads no server state, stores no input, and produces the same output for the same normalized category. It does not judge whether a code is appropriate for a particular business case, expand vendor-specific codes, or interpret a response body. Because registries can evolve as specifications add assignments, consumers that require a legally or operationally authoritative current registry should also retain the specification version used by their project. The browser and API share this deterministic solver; an API call costs $0.002.

Build API documentation tables

Generate an ordered reference table for one response class with consistent numeric codes and reason phrases.

Validate response policies

Compare an application's allowed responses with the assigned codes in the intended HTTP category.

Populate developer tooling

Fill grouped selectors, cheat sheets, and protocol-learning interfaces from a deterministic structured result.

Which category names are accepted?

Use informational, success, redirect, client error, or server error. Matching is case-insensitive and also accepts hyphens or underscores in multiword names.

Does the list include every number in the category range?

No. It includes assigned standard codes and omits unassigned gaps within each 1xx, 2xx, 3xx, 4xx, or 5xx range.

Why is status 418 labeled Unused?

The current core HTTP registry reserves 418 as Unused. The well-known teapot wording originated in an experimental specification.

Can this check a live URL?

No. It is a deterministic reference lookup and makes no network requests. Use an HTTP inspection capability to examine a live endpoint.

Are reason phrases transmitted by every HTTP version?

No. Reason phrases are conventional labels, and HTTP/2 and HTTP/3 do not transmit a reason-phrase field. Program logic should use the numeric code.

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.

POSThttps://api.kit.forhosting.com/dev2/http-status-by-category

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.

curl -X POST https://api.kit.forhosting.com/dev2/http-status-by-category \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"category":"client error"}'
{
  "category": "client error"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev2.http_status_by_category",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →