# host-tools — full content > Free developer tools for everyday tasks — JSON, encoding, hashing, DNS and HTTP checks. No sign-up, no paywall, and nothing you paste into a local tool is uploaded. Source: https://host-tools.com Documents: 27 Every page below is reproduced in full as Markdown, in the order it appears in the site index. Line breaks and headings are the originals. --- # HTTP Status Codes Source: https://host-tools.com/reference/http-status-codes/ > Every HTTP status code with its reason phrase, whether it is cacheable, whether it can carry a body, and when to use it. ## What are HTTP status codes? Every HTTP response starts with a three-digit status code that tells the client how the request went. The first digit defines the class: - **1xx** — informational: the server received the request and is continuing. - **2xx** — success: the request was received and processed. - **3xx** — redirection: the client must take an extra step, usually following a redirect. - **4xx** — client error: the request is malformed or not allowed. - **5xx** — server error: the server failed to fulfil an otherwise valid request. ## How to read the table The table is grouped by class. Two of its columns come straight from the specification rather than from opinion: - **Cacheable** — whether a cache may reuse the response *by default*. RFC 9110 defines exactly twelve codes as heuristically cacheable: `200`, `203`, `204`, `206`, `300`, `301`, `308`, `404`, `405`, `410`, `414` and `501`. Every other code is only cached when the response says so explicitly. - **Body** — whether the response may carry a body. The whole `1xx` class cannot contain content, `204` and `304` send no representation, and `205` must not generate content. Use the search box to filter by code, reason phrase or description. To see which code a live site actually returns — including every redirect — use the [Website Status Checker](/tools/website-status/). ## Which code should you return? The table tells you what a code means. This is the other half: what to send. ### Creating a resource | Situation | Code | | --- | --- | | You created a new resource | `201 Created` — include a `Location` header | | You accepted work to do later | `202 Accepted` | | It worked and there is nothing to return | `204 No Content` | | It worked and the client keeps its current view | `200 OK` | ### Redirects | Code | Permanent? | Preserves the method? | | --- | --- | --- | | `301` | Yes | No — a `POST` becomes a `GET` | | `302` | No | No — same problem, and it is the accidental default | | `303` | No | No — that is the point: “look over there, with `GET`” | | `307` | No | Yes | | `308` | Yes | Yes | Moving a `GET`-only URL permanently: `301`. Moving an endpoint where the method and body matter: `308` if permanent, `307` if temporary. Avoid `302` for a permanent move — browsers treat it as temporary and signals do not transfer. ### Client errors | Code | Use it when | | --- | --- | | `400` | The request is malformed and authenticating would not help | | `401` | The client is not authenticated — send `WWW-Authenticate` | | `403` | The client is authenticated but not allowed; retrying will not help | | `404` | The resource does not exist, or you do not want to reveal that it does | | `405` | The method is wrong for this URL — send `Allow` | | `409` | The request conflicts with the current state (duplicate key, stale version) | | `422` | The body parses but fails validation | | `429` | Rate limited — send `Retry-After` | The pair people get wrong most often is `401` versus `403`: `401` asks “who are you?”, `403` says “I know who you are, and no”. ### Server errors `500` is the catch-all for a bug. When you can be precise, be precise: `502` and `504` mean an upstream service answered badly or too slowly, and `503` means you are overloaded or in maintenance — and only `503` lets you send `Retry-After` so clients back off politely instead of hammering you. ## Codes that carry no body `1xx`, `204`, `205` and `304` cannot carry a body. Sending one is a protocol error, not just wasted bytes. `304` is the easiest to get wrong: it must not repeat the body of the `200` it replaces, only the headers the cache needs to update. ## Sources Reason phrases and cacheability follow the [IANA HTTP Status Code Registry](https://www.iana.org/assignments/http-status-codes/) and RFC 9110 (*HTTP Semantics*). Legacy codes that are no longer in use (`305 Use Proxy`, `306 Switch Proxy`) are omitted on purpose. --- # MIME Types Source: https://host-tools.com/reference/mime-types/ > A filterable reference of common MIME types with their file extensions and categories. ## What is a MIME type? A MIME type (also called media type or content type) is a two-part label in the form `type/subtype` that describes the format of a resource. Servers send it in the `Content-Type` header so browsers and clients know how to interpret the response. ## How to use this reference Filter by type, extension or description with the search box below. The list covers the most common types; the authoritative registry is maintained by IANA. A few legacy aliases that are still widely used (such as `text/javascript`) are noted in their description. --- # Base64 Encoder / Decoder Source: https://host-tools.com/tools/base64/ > Encode and decode Base64 text locally in your browser, UTF-8 safe. ## What does this tool do? Base64 encodes binary or text data as printable ASCII characters, which is how images, files and credentials are embedded in URLs, JSON and emails. This tool does both directions in one place: paste text to **encode** it, or paste Base64 to **decode** it back. ## What is Base64? Base64 maps every 3 bytes of input to 4 characters from the 64-character alphabet `A-Z a-z 0-9 + /`. The `=` padding at the end marks how many bytes the original data had. ## Keep in mind Base64 is **encoding, not encryption**: anyone can decode it, so never rely on it to protect secrets. Everything here runs locally in your browser, so your data never leaves your machine. --- # QR Code Generator Source: https://host-tools.com/tools/qr-code-generator/ > Create QR codes locally in your browser — no signup, no watermark, no tracking. Download as clean SVG or PNG. ## What does this tool do? QR Code Generator turns any text or URL into a QR code — the two-dimensional barcode that phones scan with their camera. Type or paste your content, choose an error correction level, and download the result as a **clean SVG or PNG**. Everything happens **in your browser**. The content you type is encoded locally and never uploaded, and the download has **no watermark, no logo and no tracking**. ## Why no watermark and no tracking matters Most QR generators watermark the PNG or gate the download behind an email. This one doesn't. The QR you download is exactly what your scanner sees: a clean black-on-white matrix with the standard quiet zone. Nothing is injected, and no network request is made while generating. ## Error correction levels A QR code embeds redundant data so it can still be read if part of it is damaged or covered. You choose how much redundancy to add: | Level | Recovery | Use it when | | --- | --- | --- | | **L** | ~7 % | Maximum data density, clean printing, controlled conditions | | **M** | ~15 % | Good default for screens and general use | | **Q** | ~25 % | Codes that may get dirty or partially covered | | **H** | ~30 % | Logos overlaid on the code, harsh environments | More recovery means a denser, larger code for the same content. If the content doesn't fit at the level you picked, lower the level (for example from H to M). ## The quiet zone Every QR code needs a **quiet zone**: a clear margin around the matrix, at least **4 modules** wide, so scanners can tell where the code starts and ends. This tool includes the 4-module quiet zone automatically in both the SVG and the PNG. ## How much fits in a QR code Capacity depends on the content and the error correction level. A QR code has 40 sizes ("versions"); the largest (version 40) holds at most about **2,900 bytes** of arbitrary data. Plain text and URLs encode more efficiently than random binary content, and numbers encode more efficiently still. For a URL or a short text you will almost never hit the limit. If your content is too long, shorten it or lower the error correction level. ## Content formats that just work You can encode any string. Common formats are just text written in a standard way — no special mode is needed: - **URL** — `https://example.com/page` - **Email** — `mailto:hello@example.com?subject=Hi` - **Phone** — `tel:+34600123456` - **SMS** — `SMSTO:+34600123456:Hello` - **Wi-Fi** — `WIFI:T:WPA;S:NetworkName;P:Password;;` - **Contact (vCard)** — a `BEGIN:VCARD … END:VCARD` block Paste any of these exactly as shown and the result will open the right app when scanned. ## What this tool does not do No dynamic QR codes, no scan analytics, no account, no logo uploads. It produces a static QR code from your content and nothing else. Scan carefully: like any QR code, a code that encodes a link will open that link on the phone that scans it. --- # URL Encoder / Decoder Source: https://host-tools.com/tools/url-encoder/ > Percent-encode and decode URL components locally in your browser. ## What does this tool do? URLs can only contain a limited set of ASCII characters. Percent-encoding (also called URL encoding) replaces reserved or non-ASCII characters with a `%` followed by two hex digits — for example a space becomes `%20`. This tool encodes text into percent-encoded form and decodes it back, entirely in your browser. ## When you need it You use URL encoding when building query strings, form data or links with special characters. Encoding is **not** encryption: it only makes text safe to put in a URL. --- # UUID Generator Source: https://host-tools.com/tools/uuid-generator/ > Generate RFC 4122 version 4 UUIDs in bulk and copy them with one click, entirely in your browser. ## What is a UUID v4? A Universally Unique Identifier (UUID) is a 128-bit number written as 32 hexadecimal digits in the form `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`. Version 4 UUIDs are generated from random data, so each one is effectively unique — perfect for database primary keys and API identifiers. UUIDs are generated locally in your browser using the Web Crypto API, so nothing is sent to any server. --- # CSV to JSON Source: https://host-tools.com/tools/csv-to-json/ > Convert CSV rows to a JSON array of objects locally in your browser. ## What does this tool do? It turns a CSV table into a JSON array of objects. The first row is read as the header, and each following row becomes an object. Everything runs locally in your browser. ## How values are typed Every cell is trimmed and then converted automatically: | Cell | Becomes | | --- | --- | | `true` / `false` | boolean | | `null` | `null` | | `42`, `-3`, `7.5` | number | | empty | empty string | | anything else | string | There is no switch to turn this off, which matters for values that only *look* numeric: - **Leading zeros are lost.** `01234` becomes `1234`, so postal codes and zero-padded ids get corrupted. - **Long integers lose precision.** Past 15–16 digits JavaScript numbers round: `12345678901234567890` becomes `12345678901234567000`. - **`007.50` becomes `7.5`.** If those values matter, make them non-numeric before converting (a text prefix such as `zip:01234`, for example) and strip it from the JSON afterwards. ## Delimiters and quoting - Only the **comma** separates fields. Semicolon- or tab-separated files are read as a single column, so convert them to commas first. - Fields may be quoted with `"` and contain commas or line breaks. A doubled quote (`""`) is one literal quote. - CRLF, CR and LF line endings are all accepted. - A column with an **empty header is skipped**. - If two headers share a name, the **last column wins** and the earlier one is dropped. - Blank rows are ignored. ## Converting back is not lossless JSON to CSV and back is a one-way trip for types: a number becomes a number again, an empty field becomes `""` rather than staying absent, and `null` comes back as an empty value. Keep the original file if you need an exact round trip. --- # JSON Formatter Source: https://host-tools.com/tools/json-formatter/ > Beautify and format JSON with selectable indentation, instantly in your browser. No upload, no sign-up. ## What is a JSON formatter? A JSON formatter (also called a beautifier or pretty printer) takes minified JSON — the compact payload an API returns — and indents it so a human can read it. It also validates the document: if the syntax is wrong, you get the exact error instead of a silent failure. ## Why this one? Formatting runs entirely in your browser: nothing you paste is sent to or stored on any server. Paste an API response straight from DevTools, pick your indentation, and copy the readable result. --- # JSON Minifier Source: https://host-tools.com/tools/json-minifier/ > Compress JSON to a single compact line to save bytes in API responses and config files. ## What is a JSON minifier? A JSON minifier removes insignificant whitespace from a JSON document, producing a single compact line that is smaller to send over the network and faster to parse. ## Why this one? It validates the document first (invalid JSON is never silently corrupted), reports how many characters you saved, and never uploads your data anywhere. ## What minifying can change Minification parses your JSON and writes it back out. That is what makes it safe from a *syntax* point of view, but it also normalises some values. Real examples: | Input | Output | Why | | --- | --- | --- | | `1.0` | `1` | Numbers are written back in their shortest form | | `-0` | `0` | Negative zero is not preserved | | `12345678901234567890` | `12345678901234567000` | JavaScript numbers lose precision past 15–16 digits | | `{"a":1,"a":2}` | `{"a":2}` | Duplicate keys collapse; the last one wins | | `{"10":1,"2":1,"1":1}` | `{"1":1,"2":1,"10":1}` | Integer-like keys are reordered | The whitespace *inside* strings is untouched, and escapes such as `\n`, `\t` and `\u00e9` are preserved. If any of the changes above would hurt you, store the value as a string (an id, for example) and check the output before shipping it. --- # JSON Query Source: https://host-tools.com/tools/json-query/ > Query, filter and transform JSON with jq expressions, locally in your browser. No upload, no sign-up. ## What is JSON Query? JSON Query runs jq — the standard command-line JSON processor — entirely in your browser. Type a jq expression to filter, extract, map, sort or aggregate a JSON document and see the result instantly. Nothing is uploaded: your data and your query stay on your device. ## Common jq patterns Start with the preset buttons and edit the expression to explore. The basics: - `.users[]` — iterate over an array. - `select(.age >= 30)` — keep only elements that match a condition. - `map({ name, age })` — reshape each element into a new object. - `sort_by(.age)` — sort by a field (add `| reverse` for descending). - `[.users[].city] | unique` — collect a field and remove duplicates. - `[.users[].age] | add` — sum a field across the array. ### Filter `.users[] | select(.age >= 30)` returns only the users aged 30 or more. ### Extract a field `.users[].name` returns the `name` of every user, one per line. ### Reshape with map `.users | map({ name, email })` builds a new array with only the fields you keep. ### Sort `.users | sort_by(.age) | reverse` orders users from oldest to youngest. ### Aggregate `[.users[].age] | add` sums every age into a single number. ## When to use JSON Query vs the other JSON tools - Use **JSON Formatter** to pretty-print a whole document. - Use **JSON Validator** to find a syntax error and its exact position. - Use **JSON Minifier** to compress a document for production. - Use **JSON Query** when you need to *select, filter, transform or aggregate* part of a document — something none of the others do. --- # JSON to CSV Source: https://host-tools.com/tools/json-to-csv/ > Convert a JSON array of objects to CSV locally in your browser. ## What does this tool do? It turns a JSON array of objects into a CSV table. The first row becomes the header (the union of all object keys), and each object becomes a row. Values that contain commas, quotes or line breaks are quoted correctly, so the output is valid CSV. ## Keep in mind The input must be a JSON **array of objects**. Nested objects are serialized as JSON strings inside a single cell. Everything runs locally in your browser. --- # JSON to TypeScript Source: https://host-tools.com/tools/json-to-typescript/ > Generate TypeScript interfaces and types from a JSON document, locally in your browser. Nested interfaces, arrays, optional fields and unions — no upload. ## What does this tool do? JSON to TypeScript turns the **structure** of a JSON document into TypeScript interfaces and type aliases. Paste a JSON object or array and it infers the types you would otherwise write by hand: nested objects become nested interfaces, arrays become `T[]`, and missing fields become optional properties. ## How the inference works The generator follows a small, predictable set of rules: - **Objects become interfaces.** Each object — the root, nested objects and objects inside arrays — gets its own named interface. - **Arrays of objects are merged.** When array items differ, their shapes are merged and fields missing in some items become optional (`name?: string`). - **`null` becomes a union.** A field that is `null` in one item and `string` in another is inferred as `string | null`. - **Incompatible types become unions.** A field holding both numbers and strings is inferred as `number | string`. - **Empty arrays become `unknown[]`.** With no items, there is nothing to infer from, so the tool says so explicitly instead of guessing. - **Names are normalized.** `snake_case`, `kebab-case` and `camelCase` keys are converted to PascalCase (`user_profile` → `UserProfile`), arrays are singularized (`users` → `User`), and keys that would not be valid TypeScript identifiers are fixed. ## When to use it - Typing an API response you have as a sample payload. - Bootstrapping types for a config file or fixture before tightening them. - Generating a starting point you then refine into a hand-written type. It is a **structural** converter: it reads shapes, not runtime semantics. It does not know that `2026-09-10` is a date or that `"1"` should be a number — it reports what is actually there. ## JSON to TypeScript vs the rest of the JSON tools - **JSON Formatter** beautifies raw JSON. - **JSON Validator** checks syntax and reports errors with position. - **JSON Query** extracts data from a document. - **JSON to TypeScript** generates static types from the structure. Each answers a different question about the same document. ## Limitations - Inference is structural and lossy: it cannot recover information that is not in the sample (empty arrays, `null`-only fields). - Array item merging is heuristic; genuinely mixed arrays become unions or optional fields rather than a single perfect type. - Generated names are a best effort for pluralization and casing — rare keys may need manual renaming. ## Privacy Your JSON is parsed and converted locally in your browser. Nothing is uploaded, stored or sent anywhere. --- # JSON Validator Source: https://host-tools.com/tools/json-validator/ > Validate JSON syntax and get the exact line and column of the first error, plus document statistics. ## What is a JSON validator? A JSON validator checks whether a document is syntactically valid and, when it is not, tells you exactly where the parser failed — line and column — instead of just "invalid JSON". ## What you get Besides validity, this tool counts the objects, arrays, keys and characters of your document, so you can spot structural problems at a glance. Everything runs in your browser. ## What counts as valid This tool checks **syntax** — the rules of JSON (RFC 8259). Two consequences are worth knowing before you trust a green check: - **Duplicate keys are accepted.** `{"a": 1, "a": 2}` is valid JSON, and when it is parsed the last value wins. This tool does not flag it, so a repeated key will not show up as an error. - **It is not a JSON Schema validator.** It confirms the document parses, not that it matches a shape you were expecting. Field names, types and required properties are out of scope here. ## Why a document gets rejected These look like JSON but are not part of the specification: - comments (`//` or `/* */`) — that is JSONC, not JSON - a trailing comma after the last element - single quotes instead of double quotes - unquoted keys - `NaN`, `Infinity` and `undefined` - a byte order mark (BOM) before the opening brace The reported line and column point to where the parser gave up, which is usually just after the real mistake — so look slightly before them. --- # YAML Validator Source: https://host-tools.com/tools/yaml-validator/ > Validate YAML and locate syntax errors with line, column and a code frame — locally in your browser, nothing uploaded. ## What does this tool do? YAML Validator checks whether a YAML document is syntactically valid. If it is, you get a clear confirmation and the number of documents found. If it is not, you get the error with its **line and column** and a short code frame pointing at the problem — so you can fix it without guessing. ## What YAML is validated This tool validates **YAML 1.2 (core schema)**. That means plain scalars stay plain: `yes`, `no`, `on` and `off` are strings, and a value such as `2026-09-10` is a string, not a date. It accepts the usual structure — nested mappings, sequences, quoted and multiline strings, and numbers. ## Indentation: spaces, not tabs YAML is indentation-sensitive, and **tabs are not allowed** for indentation. A common source of errors is mixing tabs and spaces, or dedenting a mapping at the wrong column. The validator reports exactly where the indentation breaks. ## Anchors, aliases and merge keys Anchors (`&name`), aliases (`*name`) and merge keys (`<<: *name`) are supported, so you can validate configurations that reuse blocks. Undefined aliases and malformed anchors are reported as errors. ## Multi-document YAML A stream separated by `---` markers is validated as multiple documents. An error in any document is reported with the line and column where it occurs. ## Duplicate keys Duplicate mapping keys are treated as invalid. If the same key appears twice, the validator reports it, because relying on "the last one wins" is a frequent source of configuration bugs. ## YAML Validator vs Code Formatter These are different jobs: - **Code Formatter** makes YAML look tidy (indentation and spacing). - **YAML Validator** tells you whether it is valid and exactly where it breaks. A file can be invalid but "formatted", or valid but ugly. Use each for what it does. ## Limits Inputs up to about 500 KB validate instantly. Between 500 KB and 1 MB you will see a warning, and inputs above 1 MB are rejected. YAML parsing is slower than JSON, so this limit keeps the tool responsive in the browser. ## Privacy Your YAML is parsed locally in your browser. It is not uploaded, stored or sent anywhere — safe for secrets in configuration files. --- # Hash Generator Source: https://host-tools.com/tools/hash-generator/ > Generate MD5, SHA-1, SHA-256, SHA-384 and SHA-512 hashes locally in your browser. ## What does this tool do? A hash function turns any input into a fixed-size "fingerprint". The same input always produces the same hash, and changing a single character changes the whole hash. This tool computes MD5, SHA-1, SHA-256, SHA-384 and SHA-512 locally in your browser. ## When to use each algorithm - **MD5** and **SHA-1** are fast but cryptographically broken — use them only for checksums and legacy compatibility, never for security. - **SHA-256** is the modern default for integrity checks, signatures and file verification. - **SHA-384** and **SHA-512** are stronger variants of the SHA-2 family. Hashes are one-way: you cannot recover the original input from its hash. --- # HMAC Generator Source: https://host-tools.com/tools/hmac-generator/ > Generate keyed HMAC-SHA1, SHA-256, SHA-384 and SHA-512 signatures locally in your browser. For webhooks, APIs and signed messages. ## What does this tool do? HMAC (Hash-based Message Authentication Code) is a keyed hash: it turns a message into a fixed-size signature using a secret key. Unlike a plain hash, the signature can only be reproduced by someone who knows the secret, so it proves both integrity and authenticity. This tool computes HMAC-SHA-1, HMAC-SHA-256, HMAC-SHA-384 and HMAC-SHA-512 locally in your browser. ## When to use HMAC - **Webhook signatures.** Providers such as GitHub and Stripe sign webhook payloads with HMAC so you can verify the request really came from them. - **API authentication.** Signed request schemes use HMAC to authenticate without sending the secret itself. - **Signed tokens and cookies.** HMAC produces tamper-evident values: any change to the message breaks the signature. ## How to verify a webhook signature 1. Paste the raw request body into *Message / payload*. 2. Paste the shared secret into *Secret key*. 3. Select the algorithm the provider documents (usually SHA-256). 4. Compare the result with the signature header. If they match, the payload is authentic. ## HMAC vs a plain hash A plain hash (see [Hash Generator](/tools/hash-generator/)) proves nothing about who created the value — anyone can hash. HMAC requires the secret key, so a valid signature is evidence that the sender knows the secret. ## Which algorithm should I use? - **SHA-256** is the modern default for webhooks and signed messages. - **SHA-384** and **SHA-512** are stronger variants of the SHA-2 family. - **SHA-1** is considered weak — keep it only for legacy integrations. ## Privacy Everything runs locally in your browser. The secret key and the message are never uploaded. --- # JWT Decoder Source: https://host-tools.com/tools/jwt-decoder/ > Decode and inspect JWT header and payload locally in your browser — without verifying the signature. ## What does this tool do? A JSON Web Token (JWT) is three base64url-encoded parts — header, payload and signature — separated by dots. This tool decodes the header and payload so you can inspect the claims, algorithm and expiry timestamps. ## ⚠️ Important Decoding a JWT **does not verify its signature**. This tool tells you what is inside a token, but it does **not** prove the token is authentic or was issued by who it claims to be. Never trust a token's claims just because they decode successfully. Everything here runs locally in your browser. --- # Signing Key Generator Source: https://host-tools.com/tools/signing-key-generator/ > Generate RSA, ECDSA and Ed25519 signing key pairs locally in your browser, exported as JWK and PEM. For JWT and application signing — not SSH keys or certificates. ## What does this tool do? Signing Key Generator creates public/private key pairs in your browser using Web Crypto. It supports RSA (2048, 3072 and 4096 bits), ECDSA (P-256 and P-384) and Ed25519, and exports each pair in two formats: **JWK** (JSON) and **PEM** (`PUBLIC KEY` / `PRIVATE KEY`). ## This tool does not generate SSH keys or certificates The keys produced here are **cryptographic signing keys**, intended for signing JWTs, application messages and Web Crypto use. They are **not** OpenSSH keys, TLS certificates or certificate signing requests (CSRs). ## Supported algorithms - **RSA** — 2048, 3072 or 4096 bits. Broad compatibility; used for RS256 JWTs. - **ECDSA** — P-256 or P-384. Smaller keys, used for ES256 / ES384 JWTs. - **Ed25519** — modern, fast and compact; used for EdDSA JWTs. Not available in some older browsers; choose ECDSA if you need maximum compatibility. ## JWK vs PEM - **JWK** is the JSON format used directly by Web Crypto and JWT libraries. It carries every parameter of the key in a single object. - **PEM** is the base64 text format used by OpenSSL, nginx, and most server tooling. The private key is exported as PKCS#8 (`PRIVATE KEY`), the public key as SPKI (`PUBLIC KEY`) — standard formats, not a custom encoding. ## When to use signing keys - Signing **JWTs** (RS256, ES256, ES384 or EdDSA). - Signing webhook responses or API payloads with your own public/private pair. - Setting up asymmetric verification in services that accept JWK or PEM. ## How it works Keys are generated locally with your browser's cryptographically secure random number generator (CSPRNG). The private key never leaves your device. ## Privacy Everything runs locally in your browser. Nothing is uploaded. --- # Code Formatter Source: https://host-tools.com/tools/code-formatter/ > Format and beautify JavaScript, TypeScript, JSON, CSS, HTML, Markdown, YAML, XML and SQL, locally in your browser. No upload, no sign-up. ## What is Code Formatter? Code Formatter beautifies source code and structured text in your browser. Pick a language, paste your code and press Format to get consistent indentation, spacing and line breaks. It runs on [Prettier](https://prettier.io), the same formatter used by editors and CI pipelines, so the output matches what your toolchain would produce. Everything runs locally: your code never leaves your device. ## Supported languages - JavaScript - TypeScript - JSON - CSS - HTML - Markdown - YAML - XML - SQL Each language's parser is downloaded only when you select it, so the page stays light. ## When to use Code Formatter vs JSON Formatter - Use **JSON Formatter** when you work specifically with JSON: it is the dedicated tool for that format, with indentation options. - Use **Code Formatter** when you need one place to format several languages, or a language that has no dedicated tool here yet (CSS, HTML, Markdown, YAML, XML, SQL). If you need to check that JSON is syntactically valid, use **JSON Validator**; if you need to compress it, use **JSON Minifier**. --- # HTML Editor Source: https://host-tools.com/tools/html-editor/ > Edit HTML visually or directly in the source — a browser-based WYSIWYG HTML editor with live source editing. No upload, no sign-up. ## What is an HTML editor? HTML Editor lets you author and edit content visually while keeping direct access to the HTML source. Write in the WYSIWYG panel, or type HTML in the source panel and apply it — both stay in sync. Everything runs locally in your browser. Nothing is uploaded. ## Edit HTML visually The left panel is a WYSIWYG editor: use the toolbar to add headings, bold, italic, underline, strikethrough, lists, quotes, links, inline code and code blocks. Formatting you apply here is converted to HTML automatically. ## Edit HTML source The right panel is the HTML source. Edit it and press **Apply HTML** to update the visual editor. Imported or edited HTML is sanitized first. ## What HTML is preserved - Headings (`h1`–`h3`) - Paragraphs - Bold, italic, underline and strikethrough - Bullet and numbered lists - Links (with `href`) - Blockquotes - Inline code and code blocks - Horizontal rules ## What is removed Anything else is stripped for safety and compatibility: scripts, iframes, images, tables, inline styles and event handlers are not supported in this version. If imported HTML contains them, you will see a notice telling you they were removed. ## When to use HTML Editor vs Code Formatter - Use **Code Formatter** to format HTML source code (indentation, spacing). - Use **HTML Editor** to write or edit content visually and convert between rich text and HTML. They cover different jobs: formatting code versus authoring content. --- # Regex Tester Source: https://host-tools.com/tools/regex-tester/ > Test regular expressions against text and see every match, locally in your browser. ## What does this tool do? A regular expression (regex) is a pattern for matching text. This tool evaluates a pattern against your text and lists every match, using the same regex engine as JavaScript — so what you see here is what you get in the browser or Node.js. ## What you get - **Every match, not just the first.** The global flag is applied for you, so the list shows all occurrences in the text. - **Whole matches only.** Capture groups are not listed: `(\w+)@(\w+)` returns `ana@example.com`, not the separate `ana` and `example.com`. To inspect groups, run the same pattern in your own code. - **Flags**: `i` (ignore case), `m` (multiline `^` and `$`), `s` (`.` matches newlines) and `u` (Unicode). ## Keep in mind Different languages have slightly different regex flavors. Results here reflect the JavaScript (ECMAScript) engine, which covers the vast majority of day-to-day patterns. Matching happens as you type, so a pattern with catastrophic backtracking — `^(a+)+$` is the classic example — can freeze the tab on the wrong input. If the page stops responding, clear the pattern field and simplify the expression. --- # Text Counter Source: https://host-tools.com/tools/text-counter/ > Count words, characters, lines, sentences and paragraphs of your text, locally in your browser. ## What does this tool do? Paste or type text and get six metrics in real time: words, characters, characters without spaces, lines, sentences and paragraphs. It is useful for essays, social posts with character limits, code and anything with length constraints. ## How it counts - **Words** are runs of non-whitespace characters. - **Lines** are separated by newline characters. - **Sentences** end with `.`, `!`, `?` or `…`. Everything runs locally in your browser, so your text never leaves your machine. --- # Text Diff Source: https://host-tools.com/tools/text-diff/ > Compare two texts or code snippets side by side, line by line, entirely in your browser. See added, removed and unchanged lines — no upload. ## What is a text diff? A text diff compares two versions of a text and shows exactly what changed between them: which lines were added, which were removed and which stayed the same. It is the same idea behind `git diff`, code review tools and "track changes" in editors. ## How line-by-line comparison works This tool splits each input into lines and aligns them so unchanged lines stay together. Added and removed lines are marked and counted. Everything happens locally in your browser using a Myers diff algorithm — nothing is sent to a server. ## Side-by-side vs unified - **Side-by-side** shows both texts in two columns, with matching lines aligned. It is the clearest way to read small or medium comparisons. - **Unified** shows a single stream with `-` (removed), `+` (added) and context lines, plus a hunk header (`@@`). It matches the classic diff format and is easier to copy or share. Use side-by-side to read a diff, and unified to copy or paste it into a patch, a comment or a ticket. ## What added, removed and unchanged mean - **Added** lines exist only in the *Modified* text. - **Removed** lines exist only in the *Original* text. - **Unchanged** lines are identical in both. The counter above the result summarizes the changes at a glance. ## Comparing text, code and data Text Diff compares by lines, so it works equally well for prose, source code, configuration, JSON, YAML or logs. It does not interpret the content — the same algorithm compares any text. ## Limitations of line diff A line diff marks a whole line as changed when anything in it differs. To see what changed *within* a single line, use an editor with word-level diff. This tool intentionally keeps line-level comparison for simplicity and speed. ## Size limits Inputs up to about 1 MB compare instantly. Above that, you will see a warning that the comparison may take a moment. Inputs above 5 MB are too large to compare responsively in a browser, so they are rejected with a clear message. ## Privacy Your text stays in your browser. There is no upload, no storage and no account. ## Example Load the example to compare two small JavaScript configs and see a typical line-by-line diff. --- # Cron Expression Source: https://host-tools.com/tools/cron-expression/ > Validate, explain, build and preview the next runs of a cron expression — with timezone and DST handling, locally in your browser. ## What does this tool do? Cron Expression has two modes. **Explain** validates a cron schedule, explains it in plain English and shows the next executions as real dates in your timezone. **Build** constructs an expression from common frequencies — every N minutes, daily, weekly and so on — and immediately explains it and lists the next runs. Everything is computed locally in your browser. ## The five (and six) fields A classic cron expression has five fields: | Field | Values | |---|---| | minute | 0–59 | | hour | 0–23 | | day of month | 1–31 | | month | 1–12 | | day of week | 0–6 (0 = Sunday) | A six-field expression prepends **seconds** (0–59). This tool accepts exactly five or six fields. A seventh (year) field is not supported, and neither is `@reboot`, because it has no regular schedule. ## Field syntax - `*` means every value. - `*/5` means every fifth value (a step). - `1-5` is a range. - `1,3,5` is a list. - `1-5/2` combines a range and a step. ## Day of month and day of week When both day-of-month and day-of-week are restricted, this tool follows the standard (Vixie) semantics and treats them as an **OR**: the expression fires on either match. `0 0 1 * 0` runs at midnight on the 1st of the month *and* every Sunday. ## Extensions: L, W, # and ? Beyond classic cron, this tool supports common extensions: - `L` — the last day of the month. - `W` — the nearest weekday to a given day. - `#` — the nth weekday of a month (`5#3` = third Friday). - `?` — "no specific value", treated as `*` for that field. These are extensions, not part of plain POSIX cron. They are supported consistently here and explained in the result. ## Aliases `@yearly`, `@annually`, `@monthly`, `@weekly`, `@daily`, `@midnight` and `@hourly` are accepted shortcuts. `@reboot` is not, because it does not represent a regular schedule. ## Build mode If you do not know cron syntax, switch to **Build**. It generates an expression from common schedules: - Every minute - Every N minutes - Hourly - Daily - Weekly (pick the weekdays) - Monthly (pick the day of the month) - Yearly (pick the month and day) Each change updates the expression, its explanation and the next runs immediately. The builder covers these common patterns only — it is not a way to represent every possible cron expression. For anything beyond them, switch to Explain and type the expression directly. ## Timezone and DST Runs are shown in a real IANA timezone (your browser timezone by default, or any you choose). Daylight saving transitions are handled correctly: a time that does not exist on a spring-forward day is shifted forward, and a time that occurs twice on a fall-back day is reported once. ## Examples - `*/5 * * * *` — every five minutes. - `0 9 * * 1-5` — at 09:00, Monday through Friday. - `0 0 1 * *` — at midnight on the first day of each month. - `30 14 15 6 *` — at 14:30 on June 15. - `0 0 L * *` — at midnight on the last day of each month. ## Privacy Your expression is validated and expanded locally. Nothing is uploaded or sent anywhere. --- # Unix Timestamp Converter Source: https://host-tools.com/tools/timestamp-converter/ > Convert between Unix timestamps and human-readable dates, locally in your browser. ## What is a Unix timestamp? A Unix timestamp is the number of seconds that have elapsed since 1 January 1970 00:00:00 UTC, a moment known as the Unix epoch. Because it is a single integer, it is the standard way to store and compare instants in logs, APIs, databases and file systems. The same instant is written as `1700000000` whether you are in Madrid, New York or Tokyo. ### Seconds or milliseconds? Most languages use seconds, but JavaScript's `Date.now()` returns milliseconds. The two differ by a factor of 1,000, so the same moment can be `1700000000` (seconds) or `1700000000000` (milliseconds). This tool detects both and tells you which unit it used. ### Converting timestamps To read a timestamp, convert it to a date in your own time zone. The epoch itself is always expressed in UTC, so the same timestamp maps to a different wall-clock time depending on where you are. `1700000000` is 22:13:20 UTC on 14 November 2023, but 23:13:20 in Central European Time. To create a timestamp, take a date and compute the seconds since the epoch. ### When to use each direction - Use a timestamp when storing, sorting or comparing events in code, logs and databases. - Use a human-readable date when displaying a value to users or debugging one specific event. ### Common mistakes - Confusing seconds and milliseconds, which shifts every date by a factor of 1,000. - Reading a UTC timestamp in your local time zone and misinterpreting the hour. - Storing a date as a formatted string instead of a timestamp, which breaks sorting and comparisons. --- # DNS Lookup Source: https://host-tools.com/tools/dns-lookup/ > Ask several public resolvers the same DNS question at once and see where they disagree. A, AAAA, CNAME, MX, TXT, NS, SOA and CAA, in your browser. ## What does this tool do? It asks the same DNS question to several public resolvers at once and shows you the answers grouped by what was said. When seven of them agree and one says something else, that is the thing worth looking at, and you should not have to compare rows by hand to find it. Pick a record type and a domain. Everything happens in your browser, talking straight to each resolver over DNS-over-HTTPS, which is just HTTP. ## What each answer tells you The resolvers are asked in two ways. Three of them are asked plainly, with no hint about where the question comes from. Two of them — Cloudflare and Google — are asked again from four declared regions, using EDNS Client Subnet. That hint is what makes a resolver serving a geographically distributed domain hand back a different address for each region. Sometimes the answers do not change between regions. **That is information too, not a failure.** A domain on an anycast network genuinely serves the same addresses everywhere, and a short list of one answer is the honest result. Where it does change, the map shows you at a glance which resolvers follow the region and which ones do not. Along the way you also get the CNAME chain that leads to the final record, the TTL, and whether each resolver validated DNSSEC. ## What this is not This is **not a propagation checker**, and it is worth being precise about the difference. A propagation service queries from servers it owns in dozens of countries, so it can tell you what a resolver in São Paulo has in its cache right now. We cannot see inside anybody's cache. What you get here is what several resolvers answer when asked from a declared region, which answers the practical question — *has my change taken effect, and does everybody see it the same way?* — without pretending to a precision we do not have. Two consequences worth knowing: - **Results are not perfectly reproducible.** The same query a minute later can group differently. That is each resolver's cache doing its job, not a bug. - **A resolver that does not answer** is shown as such, in red, rather than quietly dropped. ## Why it runs in your browser A DNS lookup says something about you. If you are checking a domain before pointing it at a production site, or looking up an internal name, that is not something to hand to a third party just to render a table. There is no server on our side in this path: the queries go from your browser to the resolvers, and we never see them. The world map is drawn from data built into the page, not from map tiles fetched from someone else's server, for the same reason. --- # Website Status Checker Source: https://host-tools.com/tools/website-status/ > Check whether a website is up — or trace where a link goes. Get HTTP status, response time, every redirect hop and the final URL. ## What this tool does Enter a domain or URL to check whether a website is responding — or paste a link to trace where it actually goes. The check runs server-side (so it behaves the same from any network) and reports: - the final HTTP status code, - the response time, - every step of the redirect chain, numbered, and - the final URL after all redirects. ## Redirect chains A single link can pass through several URLs before reaching its destination. This tool follows up to 10 of them and shows each one, so you can see exactly where a shortened link, an old URL or an affiliate link ends up. It follows three kinds of redirect: | Kind | What it looks like | | --- | --- | | HTTP | A `3xx` status with a `Location` header (`301`, `302`, `307`…) | | Meta refresh | `` in the HTML | | JavaScript | `location.href = '…'`, `location.replace('…')` and similar | If the chain comes back to a URL it already visited, the tool stops and tells you it found a loop instead of following it forever. ## Checking what a crawler sees Under **Advanced options** you can choose which `User-Agent` the check sends. Pick **Googlebot** to see whether your site serves Google a different page than it serves a browser — a common cause of pages that rank for the wrong content. ## What is an HTTP status code? Every HTTP response carries a status code: `2xx` means success, `3xx` a redirect, `4xx` a client error (such as `404 Not Found`) and `5xx` a server error. Seeing the exact code lets you tell "down" from "misconfigured" at a glance. ## Privacy The domain you check is sent to our backend because that is the only way to perform the lookup. Queries are not stored, and results are never turned into indexable pages. When a page redirects with a meta refresh or JavaScript, we read a small part of its HTML (at most 64 KB) to find the target. That content is never stored and never shown to you — only the resulting URL is reported. ---