# quickhelp.dev — Full Content Dump for AI Agents

> This document contains the complete content of all tools for one-shot context loading.
> Lightweight discovery: GET /llms.txt
> OpenAPI 3.1: GET /openapi.json
> MCP endpoint: GET /mcp

Total tools: 15

---
## JWT Decoder

**Slug**: `jwt-decoder`
**Category**: encoding
**API**: POST https://quickhelp.dev/api/jwt-decoder
**UI**: https://quickhelp.dev/jwt-decoder

### Description

Paste a JSON Web Token to instantly decode its header and payload. Optionally supply a secret or public key to verify the signature.

### What is it?

A JSON Web Token (JWT) is a compact, URL-safe way to represent claims. It has three base64url-encoded parts: header, payload, and signature. This tool decodes the header and payload and can optionally verify the signature.

### How to use

1. **Paste your token**: Copy your JWT string (starts with 'eyJ') and paste it into the input field.

2. **Inspect claims**: The decoded header and payload appear instantly — check exp, sub, iss, and any custom claims.

3. **Verify signature**: Enter your secret or public key and click Verify to confirm the token hasn't been tampered with.

### FAQ

**Q: Does this verify the signature?**

A: Yes — enter your HMAC secret or RSA/ECDSA public key in the Verify section. For HS* algorithms the secret is a plain string; for RS*/ES* provide a PEM public key.

**Q: Is my token sent to a server?**

A: The browser-side decoder never makes a network call. The signature-verification endpoint receives your token and key only during the verify request; neither is logged or stored.

### Examples

**Decode a basic JWT**
```json
Input:  {
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
}
Output: {
  "header": {
    "alg": "HS256",
    "typ": "JWT"
  },
  "payload": {
    "sub": "1234567890",
    "name": "John Doe",
    "iat": 1516239022
  },
  "signature": "SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
  "valid_structure": true
}
```

### Related tools

- https://quickhelp.dev/json-formatter
- https://quickhelp.dev/hash-generator
- https://quickhelp.dev/base64

---

## JSON Formatter

**Slug**: `json-formatter`
**Category**: formatting
**API**: POST https://quickhelp.dev/api/json-formatter
**UI**: https://quickhelp.dev/json-formatter

### Description

Paste raw or minified JSON and format it with configurable indentation, or minify it by removing all whitespace. Validates syntax, reports parse errors with line/column, and optionally sorts keys or repairs malformed JSON.

### What is it?

A JSON formatter parses a JSON string and re-serializes it with consistent indentation (pretty) or no whitespace (minify). This tool also catches syntax errors and reports the exact position of the problem.

### How to use

1. **Paste JSON**: Paste your raw, minified, or malformed JSON into the input field.

2. **Choose mode**: Select 'pretty' for readable output or 'minify' to compact it.

3. **Click Run**: The formatted result appears instantly. Use the Copy button to copy it.

### FAQ

**Q: What's the size limit?**

A: The API accepts up to 1 MB of JSON. For larger files, run the formatter locally with JSON.stringify.

**Q: Does it sort keys?**

A: Yes — enable the 'Sort keys' option to sort object keys alphabetically at every level of nesting.

### Examples

**Pretty-print JSON**
```json
Input:  {
  "json": "{\"name\":\"Alice\",\"age\":30}",
  "mode": "pretty",
  "indent": 2,
  "sort_keys": false,
  "repair": false
}
Output: {
  "output": "{\n  \"name\": \"Alice\",\n  \"age\": 30\n}",
  "valid": true
}
```

**Minify JSON**
```json
Input:  {
  "json": "{\n  \"name\": \"Alice\",\n  \"age\": 30\n}",
  "mode": "minify",
  "indent": 2,
  "sort_keys": false,
  "repair": false
}
Output: {
  "output": "{\"name\":\"Alice\",\"age\":30}",
  "valid": true
}
```

**Sort keys**
```json
Input:  {
  "json": "{\"z\":1,\"a\":2}",
  "mode": "pretty",
  "indent": 2,
  "sort_keys": true,
  "repair": false
}
Output: {
  "output": "{\n  \"a\": 2,\n  \"z\": 1\n}",
  "valid": true
}
```

### Related tools

- https://quickhelp.dev/jwt-decoder

---

## Image Converter

**Slug**: `image-converter`
**Category**: conversion
**API**: POST https://quickhelp.dev/api/image-converter
**UI**: https://quickhelp.dev/image-converter

### Description

Upload an image and convert it to another format. Supports PNG, JPEG, WebP, AVIF, TIFF, GIF as both input and output; SVG is accepted as input only. Maximum input size is 3 MB. Returns the converted image as a base64 string along with dimensions and file size.

### What is it?

Image Converter is a free, browser-based tool that converts image files between popular formats — PNG, JPEG, WebP, AVIF, TIFF, and GIF. SVG files can also be rasterised to any of those formats. No software to install and no sign-up required.

### How to use

1. **Upload**: Click the file picker and select your image (up to 3 MB).

2. **Choose formats**: Select the source format and your desired output format, then adjust quality if needed.

3. **Convert & download**: Click Run. A preview appears immediately and you can download the converted file.

### FAQ

**Q: What is the maximum file size?**

A: 3 MB. This is set by the Vercel free tier request body limit. For larger images, clone the repo and run locally — there is no size cap when self-hosted.

**Q: Does conversion affect image quality?**

A: Lossless formats (PNG, TIFF) preserve every pixel. Lossy formats (JPEG, WebP, AVIF) use the quality slider — 80 is a good default that balances file size and visual fidelity.

**Q: Why convert to WebP or AVIF?**

A: WebP is 25–35% smaller than JPEG/PNG at equivalent quality and is supported by all modern browsers. AVIF is 50% smaller still but takes longer to encode. Both are great for web delivery.

### Examples

**PNG to WebP**
```json
Input:  {
  "image": "<base64-png>",
  "from": "png",
  "to": "webp",
  "quality": 80
}
Output: {
  "image": "<base64-webp>",
  "format": "webp",
  "width": 800,
  "height": 600,
  "size_bytes": 24576
}
```

**JPEG to AVIF**
```json
Input:  {
  "image": "<base64-jpeg>",
  "from": "jpeg",
  "to": "avif",
  "quality": 70
}
Output: {
  "image": "<base64-avif>",
  "format": "avif",
  "width": 1280,
  "height": 720,
  "size_bytes": 38400
}
```

### Related tools

- https://quickhelp.dev/image-resizer
- https://quickhelp.dev/background-remover
- https://quickhelp.dev/jwt-decoder

---

## Background Remover

**Slug**: `background-remover`
**Category**: conversion
**API**: POST https://quickhelp.dev/api/background-remover
**UI**: https://quickhelp.dev/background-remover

### Description

Upload any image and the AI model removes the background, returning a transparent PNG. Processing runs in your browser — your image is never uploaded to our servers. Supports JPG, PNG, WebP, and more.

### What is it?

Background Remover uses an AI model running entirely in your browser to detect and remove image backgrounds, returning a transparent PNG. No image is ever sent to a server — all processing is local.

### How to use

1. **Upload**: Drop an image or click to browse. PNG, JPEG, WebP are all supported.

2. **Wait**: The AI model loads from a CDN on first use (about 40 MB, cached afterwards) then processes your image in seconds.

3. **Download**: Click Download to save the transparent PNG. Use it on websites, presentations, or social media.

### FAQ

**Q: Is my image uploaded anywhere?**

A: No. The AI model runs entirely in your browser using WebAssembly. Your image never leaves your device.

**Q: Why does the first run take longer?**

A: The AI model (~40 MB) is downloaded from a CDN on first use and cached by your browser. Subsequent runs are instant.

**Q: What image formats are supported?**

A: PNG, JPEG, WebP, AVIF, TIFF, and GIF as input. Output is always a transparent PNG.

### Examples

**Remove background from a photo**
```json
Input:  {
  "image": "<base64-image>"
}
Output: {
  "image": "<base64-transparent-png>"
}
```

### Related tools

- https://quickhelp.dev/image-converter
- https://quickhelp.dev/image-resizer

---

## LCOV Coverage Viewer

**Slug**: `lcov-viewer`
**Category**: validation
**API**: POST https://quickhelp.dev/api/lcov-viewer
**UI**: https://quickhelp.dev/lcov-viewer

### Description

Paste or upload an LCOV .info file (generated by Jest, Istanbul/nyc, Vitest, gcov, coverage.py, and more) to get a structured coverage summary with per-file breakdown. All processing runs in your browser — your code never leaves your device.

### What is it?

LCOV Coverage Viewer is a free online tool that parses LCOV .info files and displays a human-readable coverage report. LCOV is the standard output format for code coverage tools across many languages and test runners — including Jest (JavaScript), Istanbul/nyc (JavaScript), Vitest (TypeScript), gcov (C/C++), and coverage.py (Python). An LCOV .info file encodes line-by-line, function-by-function, and branch-by-branch execution data for every source file in your project. This tool reads that data and renders it as a sortable, filterable table showing which files are well-covered and which need more tests. Processing is entirely client-side — your source code and coverage data never leave your browser.

### How to use

1. **Generate your LCOV report**: Run your test suite with coverage enabled. For Jest: add --coverage and set coverageReporters: ['lcov'] in jest.config. For Vitest: set coverage.reporter: ['lcov']. For Python: run coverage run then coverage lcov. The output is a file called lcov.info or coverage/lcov.info.

2. **Upload or paste the .info file**: Drag your lcov.info file onto the upload area, or paste its raw text content into the input field. The viewer accepts any standard LCOV format regardless of which tool generated it.

3. **Inspect coverage by file**: The summary cards show overall line, function, and branch coverage percentages. The file table lists every source file with its individual coverage and colored indicators — green (≥80%), yellow (60–80%), and red (<60%). Sort any column or search by filename to find the biggest coverage gaps.

### FAQ

**Q: Is my code or coverage data sent to a server?**

A: No. The LCOV parser runs entirely in your browser in JavaScript. Your .info file is never uploaded — it is read and parsed locally. This makes the tool safe for proprietary codebases.

**Q: Which test runners and coverage tools produce LCOV output?**

A: Jest (coverageReporters: ['lcov']), Vitest (coverage.reporter: ['lcov']), Istanbul/nyc (--reporter=lcov), gcov (with lcov CLI), coverage.py (coverage lcov), Cargo/tarpaulin (--out Lcov), and most CI coverage platforms including Codecov and Coveralls.

**Q: What is the difference between line, function, and branch coverage?**

A: Line coverage counts whether each executable line was reached by at least one test. Function coverage counts whether each function was called. Branch coverage counts both sides of every conditional (if/else, ternary, switch) — a line with a conditional shows as covered even if only one branch was taken.

### Examples

**Parse a Jest LCOV report**
```json
Input:  {
  "lcov": "TN:\nSF:src/utils.ts\nFNF:3\nFNH:2\nBRF:8\nBRH:6\nDA:1,1\nDA:2,1\nDA:3,0\nLF:3\nLH:2\nend_of_record"
}
Output: {
  "summary": {
    "linesCoverage": 66.7,
    "functionsCoverage": 66.7,
    "branchesCoverage": 75,
    "linesHit": 2,
    "linesFound": 3,
    "functionsHit": 2,
    "functionsFound": 3,
    "branchesHit": 6,
    "branchesFound": 8
  },
  "files": [
    {
      "path": "src/utils.ts",
      "linesCoverage": 66.7,
      "functionsCoverage": 66.7,
      "branchesCoverage": 75,
      "linesHit": 2,
      "linesFound": 3,
      "functionsHit": 2,
      "functionsFound": 3,
      "branchesHit": 6,
      "branchesFound": 8
    }
  ]
}
```

### Related tools

- https://quickhelp.dev/json-formatter

---

## Image Resizer & Cropper

**Slug**: `image-resizer`
**Category**: conversion
**API**: POST https://quickhelp.dev/api/image-resizer
**UI**: https://quickhelp.dev/image-resizer

### Description

Upload any image to resize it to exact pixel dimensions, crop a region, rotate by 90-degree increments, or flip horizontally/vertically. Supports PNG, JPEG, WebP, AVIF, GIF input. Outputs PNG, JPEG, or WebP. The browser UI uses Canvas API — no image leaves your device.

### What is it?

Image Resizer & Cropper is a free browser-based tool for resizing images to exact pixel dimensions, cropping a region of interest, rotating by 90-degree increments, and flipping horizontally or vertically. It accepts PNG, JPEG, WebP, AVIF, and GIF input and outputs PNG, JPEG, or WebP. The browser UI uses the Canvas API for instant live preview — no image is sent to a server. The REST API (POST /api/image-resizer) processes images server-side using Sharp for use in scripts, CI pipelines, and AI agent workflows. Common use cases include resizing photos for social media, cropping product images for e-commerce, fixing portrait/landscape orientation issues, and generating thumbnails.

### How to use

1. **Upload your image**: Drag your image onto the upload area or click to browse. PNG, JPEG, WebP, AVIF, and GIF are supported. Your original dimensions appear immediately in the preview.

2. **Choose your operations**: Use the Resize tab to set target width and height (toggle the aspect ratio lock to constrain proportions), the Crop tab to trim edges or select a preset ratio (1:1, 4:3, 16:9), and the Transform tab to rotate or flip the image. Operations apply in order: rotate → flip → crop → resize.

3. **Export and download**: Select your output format (PNG for lossless, JPEG or WebP for smaller files) and quality level, then click Download. The processed image saves immediately.

### FAQ

**Q: Is my image uploaded to a server?**

A: The browser UI processes images entirely using the Canvas API — nothing is sent to any server. If you use the REST API endpoint (/api/image-resizer), your image is processed server-side using Sharp and is never stored or logged.

**Q: What is the maximum image size?**

A: The browser UI has no explicit size limit — Canvas processes as large an image as your device memory allows (typically several megabytes or more). The API endpoint accepts base64-encoded images up to 3 MB, which is the Vercel free-tier request body limit.

**Q: What does the fit option do when resizing?**

A: 'Inside' (default) scales the image to fit within the target width and height while preserving the aspect ratio — the output may be smaller than requested if proportions differ. 'Cover' fills the exact dimensions and crops the overflow. 'Fill' stretches to exactly the target size regardless of aspect ratio.

### Examples

**Resize to 400 wide, preserve aspect ratio**
```json
Input:  {
  "image": "<base64-image>",
  "width": 400,
  "fit": "inside",
  "format": "png"
}
Output: {
  "image": "<base64-png>",
  "format": "png",
  "width": 400,
  "height": 300,
  "originalWidth": 1200,
  "originalHeight": 900,
  "sizeBytes": 48230
}
```

**Crop a 200×200 square from top-left**
```json
Input:  {
  "image": "<base64-image>",
  "cropX": 0,
  "cropY": 0,
  "cropWidth": 200,
  "cropHeight": 200,
  "format": "webp",
  "quality": 80
}
Output: {
  "image": "<base64-webp>",
  "format": "webp",
  "width": 200,
  "height": 200,
  "originalWidth": 800,
  "originalHeight": 600,
  "sizeBytes": 12400
}
```

**Rotate 90° clockwise**
```json
Input:  {
  "image": "<base64-image>",
  "rotate": 90,
  "format": "jpeg",
  "quality": 85
}
Output: {
  "image": "<base64-jpeg>",
  "format": "jpeg",
  "width": 600,
  "height": 800,
  "originalWidth": 800,
  "originalHeight": 600,
  "sizeBytes": 31200
}
```

### Related tools

- https://quickhelp.dev/image-converter
- https://quickhelp.dev/background-remover

---

## Base64 Encoder / Decoder

**Slug**: `base64`
**Category**: encoding
**API**: POST https://quickhelp.dev/api/base64
**UI**: https://quickhelp.dev/base64

### Description

Encode any UTF-8 string to Base64 or decode a Base64 string back to plain text. Supports standard Base64 (RFC 4648) and URL-safe Base64 (uses - and _ instead of + and /). Detects and reports malformed input.

### What is it?

Base64 is an encoding scheme that converts binary data — or any text — into a string of 64 ASCII characters (A–Z, a–z, 0–9, +, /). It is used wherever binary data must travel through a medium that only handles text: embedding images in HTML or CSS, encoding credentials in HTTP Authorization headers, storing binary payloads in JSON, and passing data through URLs. Base64 does not encrypt data; it only changes the representation. The URL-safe variant replaces + with - and / with _ so the result is safe to embed in URLs and filenames without percent-encoding.

### How to use

1. **Paste your input**: For encoding: paste the plain text you want to convert. For decoding: paste the Base64 string (with or without padding =).

2. **Select a mode**: Choose 'encode' to convert plain text → Base64, or 'decode' to convert Base64 → plain text.

3. **Choose a charset**: Use 'standard' for general purposes. Use 'url-safe' if the result will appear in a URL, filename, or JWT — it replaces + with - and / with _.

4. **Copy the result**: Click the Copy button. The output field also shows the byte length of the source data.

### FAQ

**Q: Does Base64 encoding encrypt my data?**

A: No. Base64 is an encoding scheme, not encryption. Anyone who receives a Base64 string can decode it instantly without a key. Do not use Base64 to hide sensitive data.

**Q: What is the difference between standard and URL-safe Base64?**

A: Standard Base64 uses + and / as its 62nd and 63rd characters. These have special meaning in URLs, so URL-safe Base64 replaces them with - and _ respectively. The output is otherwise identical and interchangeable if you handle the substitution correctly.

**Q: Why does Base64 output end with = or ==?**

A: Base64 encodes every 3 bytes into 4 characters. If the input is not a multiple of 3 bytes, = padding is added to make the output length a multiple of 4. One = means 1 padding byte was added; == means 2.

**Q: Can I decode a Base64 image (data URI)?**

A: Yes — paste the part after 'data:image/png;base64,' and decode it. The output will be binary data rendered as UTF-8, which may look garbled for non-text content. For images, use the Image Converter tool instead.

**Q: Is there a size limit?**

A: The API endpoint accepts up to 1 MB of input. For larger files, use Node.js: Buffer.from(str, 'utf-8').toString('base64') for encoding, or Buffer.from(b64, 'base64').toString('utf-8') for decoding.

### Examples

**Encode text to Base64**
```json
Input:  {
  "input": "Hello, World!",
  "mode": "encode",
  "charset": "standard"
}
Output: {
  "output": "SGVsbG8sIFdvcmxkIQ==",
  "valid": true,
  "encoding": "standard",
  "byte_length": 13
}
```

**Decode Base64 to text**
```json
Input:  {
  "input": "SGVsbG8sIFdvcmxkIQ==",
  "mode": "decode",
  "charset": "standard"
}
Output: {
  "output": "Hello, World!",
  "valid": true,
  "encoding": "standard",
  "byte_length": 13
}
```

**URL-safe encode**
```json
Input:  {
  "input": "quickhelp.dev/base64?mode=encode",
  "mode": "encode",
  "charset": "url-safe"
}
Output: {
  "output": "cXVpY2toZWxwLmRldi9iYXNlNjQ_bW9kZT1lbmNvZGU=",
  "valid": true,
  "encoding": "url-safe",
  "byte_length": 32
}
```

### Related tools

- https://quickhelp.dev/jwt-decoder
- https://quickhelp.dev/json-formatter
- https://quickhelp.dev/hash-generator

---

## Hash Generator

**Slug**: `hash-generator`
**Category**: cryptography
**API**: POST https://quickhelp.dev/api/hash-generator
**UI**: https://quickhelp.dev/hash-generator

### Description

Compute cryptographic hashes of any UTF-8 string using the most common algorithms: MD5, SHA-1, SHA-256, SHA-384, and SHA-512. Output is a lowercase hex or base64 digest. Useful for verifying data integrity, generating checksums, and working with APIs that require signed requests.

### What is it?

A cryptographic hash function takes an input of any length and produces a fixed-size output — the hash or digest — that uniquely represents the input. The same input always produces the same hash; changing even a single character produces a completely different hash. Hash functions are one-way: you cannot reverse a hash to recover the original input. MD5 and SHA-1 are older algorithms still used for non-security checksums. SHA-256 and SHA-512 are current standards for security-sensitive use cases such as digital signatures, API authentication, and password storage (always combined with a proper key-derivation function like bcrypt or Argon2 for passwords).

### How to use

1. **Paste your text**: Type or paste any UTF-8 string into the input field — an API secret, a file path, a password candidate, or any value you want to fingerprint.

2. **Choose an algorithm and encoding**: Select SHA-256 for general security use, MD5 or SHA-1 for legacy checksum compatibility, or SHA-512 for the longest digest. Choose hex for a lowercase hexadecimal string or base64 for a more compact representation.

3. **Copy the hash**: The digest appears instantly. Click Copy to put it on your clipboard. The tool also shows input byte length and digest character length to help you confirm you are using the correct variant.

### FAQ

**Q: Is my input sent to a server?**

A: No. Hashing runs entirely in your browser using the Web Crypto API. Your text never leaves your device. The REST API endpoint processes input server-side in an isolated, stateless function with no logging.

**Q: Which algorithm should I use?**

A: Use SHA-256 for new projects — it is the current standard. Use MD5 or SHA-1 only when a legacy system requires it (they are broken for collision resistance but acceptable for non-security checksums). Use SHA-512 when you need a longer digest or when your framework requires it.

**Q: Can I hash a file instead of text?**

A: This tool hashes UTF-8 text. To hash a file in Node.js: createHash('sha256').update(fs.readFileSync('file')).digest('hex'). On macOS or Linux: sha256sum filename. On Windows: Get-FileHash filename -Algorithm SHA256.

### Examples

**SHA-256 hex digest**
```json
Input:  {
  "input": "Hello, World!",
  "algorithm": "sha256",
  "encoding": "hex"
}
Output: {
  "hash": "dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986d",
  "algorithm": "sha256",
  "encoding": "hex",
  "input_byte_length": 13,
  "digest_length": 64
}
```

**MD5 checksum**
```json
Input:  {
  "input": "Hello, World!",
  "algorithm": "md5",
  "encoding": "hex"
}
Output: {
  "hash": "65a8e27d8879283831b664bd8b7f0ad4",
  "algorithm": "md5",
  "encoding": "hex",
  "input_byte_length": 13,
  "digest_length": 32
}
```

**SHA-512 base64**
```json
Input:  {
  "input": "password123",
  "algorithm": "sha512",
  "encoding": "base64"
}
Output: {
  "hash": "tPIDF4Z9oUpSFsNSaDoNJEEbDSCUGhW3C9w/nABEP1JvKYa6B/D+bHnHK8Ym6WxDPjf5qLimqmJKdXSipQmUSQ==",
  "algorithm": "sha512",
  "encoding": "base64",
  "input_byte_length": 11,
  "digest_length": 88
}
```

### Related tools

- https://quickhelp.dev/base64
- https://quickhelp.dev/jwt-decoder

---

## URL Encoder / Decoder

**Slug**: `url-encoder`
**Category**: encoding
**API**: POST https://quickhelp.dev/api/url-encoder
**UI**: https://quickhelp.dev/url-encoder

### Description

Encode any string for safe use in a URL or query parameter using percent-encoding (RFC 3986), or decode a percent-encoded string back to plain text. Supports both full URL encoding (preserves ://?=& structure) and component encoding (encodes every special character). Shows a character-by-character encoding table for reference.

### What is it?

Percent-encoding (also called URL encoding) is a mechanism defined in RFC 3986 for representing characters that are not allowed or have special meaning in a URL. Every character that needs encoding is replaced by a percent sign followed by two hex digits representing the character's UTF-8 byte value — for example, a space becomes %20 and an ampersand becomes %26. There are two encoding variants: component encoding (encodeURIComponent) converts every character except the unreserved set A–Z a–z 0–9 and - _ . ! ~ * ' ( ); full URL encoding (encodeURI) additionally preserves the structural characters : / ? # [ ] @ ! $ & ' ( ) * + , ; = so that a complete URL remains navigable. Decoding reverses the process, converting all %XX sequences back to the original characters. URL encoding is required whenever you embed user-supplied text in a query string, form a redirect URL, construct a OAuth callback, or pass data through a system that only allows safe ASCII characters.

### How to use

1. **Paste your text or URL**: For query parameter values (names, search terms, user input), paste the raw text and choose 'encode-component'. For a complete URL with a path and query string, paste the full URL and choose 'encode-full'. For decoding, paste any percent-encoded string.

2. **Choose the mode**: encode-component is correct for individual parameter values — it encodes & = ? and other structural characters. encode-full is for complete URLs where you want spaces encoded but the URL structure preserved. decode reverses any percent-encoding.

3. **Copy the result**: The encoded or decoded string appears instantly. The encoding table shows exactly which characters were changed and their %XX codes — useful for debugging encoding issues in APIs or redirect URLs.

### FAQ

**Q: What is the difference between encodeURI and encodeURIComponent?**

A: encodeURI is designed for complete URLs — it leaves the structural characters (: / ? # & = + @) untouched so the URL remains valid. encodeURIComponent is designed for individual values within a URL — it encodes those structural characters too, preventing them from being misinterpreted as URL delimiters. Use encodeURIComponent for query parameter values; use encodeURI only if you have a full URL that you want to sanitise without breaking its structure.

**Q: Why does a space sometimes appear as + instead of %20?**

A: HTML forms using application/x-www-form-urlencoded encoding replace spaces with + rather than %20. Both are valid in query strings, but they are different encodings. Modern APIs and URLs use %20 (RFC 3986). If you are constructing a query string for a form submission, check whether the receiving server expects + or %20.

**Q: Is my data sent to a server when I encode or decode?**

A: No. Encoding and decoding run entirely in your browser using built-in JavaScript functions — no network request is made. The REST API endpoint is stateless and logs nothing.

### Examples

**Encode a query parameter value**
```json
Input:  {
  "input": "hello world & more=stuff",
  "mode": "encode-component"
}
Output: {
  "output": "hello%20world%20%26%20more%3Dstuff",
  "mode": "encode-component",
  "changed": true,
  "encoding_table": [
    {
      "original": " ",
      "encoded": "%20"
    },
    {
      "original": "&",
      "encoded": "%26"
    },
    {
      "original": "=",
      "encoded": "%3D"
    }
  ]
}
```

**Encode a full URL (preserve structure)**
```json
Input:  {
  "input": "https://example.com/search?q=hello world&lang=en",
  "mode": "encode-full"
}
Output: {
  "output": "https://example.com/search?q=hello%20world&lang=en",
  "mode": "encode-full",
  "changed": true,
  "encoding_table": [
    {
      "original": " ",
      "encoded": "%20"
    }
  ]
}
```

**Decode a percent-encoded string**
```json
Input:  {
  "input": "hello%20world%20%26%20more%3Dstuff",
  "mode": "decode"
}
Output: {
  "output": "hello world & more=stuff",
  "mode": "decode",
  "changed": true,
  "encoding_table": []
}
```

### Related tools

- https://quickhelp.dev/base64
- https://quickhelp.dev/json-formatter
- https://quickhelp.dev/hash-generator

---

## Unix Timestamp Converter

**Slug**: `timestamp-converter`
**Category**: datetime
**API**: POST https://quickhelp.dev/api/timestamp-converter
**UI**: https://quickhelp.dev/timestamp-converter

### Description

Convert Unix epoch timestamps (seconds or milliseconds since 1970-01-01T00:00:00Z) to ISO 8601, UTC, and local date-time strings — or parse any date string back to a Unix timestamp. Shows the relative time from now (e.g. '3 days ago'). Accepts seconds, milliseconds, or an ISO 8601 / RFC 2822 date string as input.

### What is it?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970 — a moment known as the Unix epoch. Timestamps are the universal language of time in software: databases store them as integers, APIs return them in JSON, log files record them for every event, and JWT tokens use them for 'iat' (issued-at) and 'exp' (expiry) claims. Unlike formatted date strings, Unix timestamps are unambiguous — they have no timezone, no locale, and no format variation. JavaScript and many APIs also use millisecond timestamps (Unix seconds × 1000). This tool converts in both directions: paste a timestamp to get a human-readable date in UTC and ISO 8601, or paste a date string to get the corresponding epoch seconds and milliseconds.

### How to use

1. **Paste the timestamp or date string**: Enter a Unix timestamp in seconds (e.g. 1716998400) or milliseconds (e.g. 1716998400000), or a date string in ISO 8601 format (e.g. 2024-05-29T16:00:00Z). The tool auto-detects the format.

2. **Read the converted output**: The result shows the Unix timestamp in both seconds and milliseconds, the ISO 8601 UTC string, a human-readable UTC date, and a relative time (e.g. '3 days ago' or 'in 2 hours') calculated from the current moment.

3. **Copy the value you need**: Click Copy next to the field you need — unix_seconds for database storage, iso8601 for API payloads, utc for display strings, or unix_ms for JavaScript Date objects.

### FAQ

**Q: How do I tell if a timestamp is in seconds or milliseconds?**

A: Seconds timestamps for dates after 2001 are 10 digits (≥ 1,000,000,000). Milliseconds timestamps are 13 digits (≥ 1,000,000,000,000). This tool auto-detects: any number larger than 10,000,000,000 is treated as milliseconds.

**Q: What timezone does the output use?**

A: All output is in UTC. Unix timestamps have no timezone — they always count seconds from the UTC epoch. The ISO 8601 string ends with 'Z' (Zulu / UTC). To display in a local timezone, use your application's date-formatting library with a timezone identifier (e.g. 'America/New_York').

**Q: What date formats can I convert to a Unix timestamp?**

A: Any string parseable by the JavaScript Date constructor: ISO 8601 (2024-05-29T16:00:00Z), RFC 2822 (Wed, 29 May 2024 16:00:00 +0000), or common formats like '2024-05-29'. Ambiguous formats like '05/29/2024' may be parsed incorrectly — prefer ISO 8601 with an explicit timezone offset.

### Examples

**Unix seconds to date**
```json
Input:  {
  "input": "1716998400",
  "mode": "to-date"
}
Output: {
  "unix_seconds": 1716998400,
  "unix_ms": 1716998400000,
  "iso8601": "2024-05-29T16:00:00.000Z",
  "utc": "Wed, 29 May 2024 16:00:00 UTC",
  "relative": "about 1 year ago",
  "valid": true
}
```

**ISO 8601 date to Unix timestamp**
```json
Input:  {
  "input": "2024-05-29T16:00:00Z",
  "mode": "to-timestamp"
}
Output: {
  "unix_seconds": 1716998400,
  "unix_ms": 1716998400000,
  "iso8601": "2024-05-29T16:00:00.000Z",
  "utc": "Wed, 29 May 2024 16:00:00 UTC",
  "relative": "about 1 year ago",
  "valid": true
}
```

**Unix milliseconds auto-detected**
```json
Input:  {
  "input": "1716998400000",
  "mode": "auto"
}
Output: {
  "unix_seconds": 1716998400,
  "unix_ms": 1716998400000,
  "iso8601": "2024-05-29T16:00:00.000Z",
  "utc": "Wed, 29 May 2024 16:00:00 UTC",
  "relative": "about 1 year ago",
  "valid": true
}
```

### Related tools

- https://quickhelp.dev/jwt-decoder
- https://quickhelp.dev/json-formatter

---

## UUID Generator

**Slug**: `uuid-generator`
**Category**: generation
**API**: POST https://quickhelp.dev/api/uuid-generator
**UI**: https://quickhelp.dev/uuid-generator

### Description

Generate cryptographically random UUID version 4 identifiers (RFC 4122) using the Node.js crypto module. Produces between 1 and 100 UUIDs per request, in standard hyphenated format or compact (no hyphens). Also validates whether a given string is a valid UUID.

### What is it?

A UUID (Universally Unique Identifier) is a 128-bit identifier standardised in RFC 4122 and represented as 32 hexadecimal digits in the pattern xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. UUID version 4 — the most common variant — fills all bits with cryptographically random data, making collisions statistically impossible: with 1 trillion UUIDs generated per second it would take approximately 85 years before a 50% chance of a single collision occurs. UUIDs are used as primary keys in databases, correlation IDs in distributed logs, session tokens, file names, API resource identifiers, and idempotency keys in payment systems. Because they are generated client-side without a central registry, distributed systems can create UUIDs in parallel without coordination. The compact format (no hyphens) saves 4 characters and is commonly used in URLs and file names.

### How to use

1. **Choose how many UUIDs you need**: Set the count to 1 for a single identifier or up to 100 for a bulk batch — useful when pre-generating IDs for a database seed script or test fixture.

2. **Choose a format**: Hyphenated format (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx) is the RFC 4122 standard and is accepted by most databases and ORMs. Compact format (no hyphens, 32 hex chars) is smaller and safe for URLs, file names, and systems that require alphanumeric-only keys.

3. **Copy and use**: Click Copy to put all generated UUIDs on your clipboard — one per line for multi-UUID batches. To validate an existing UUID, paste it into the 'validate' field and the tool reports whether it matches the UUID format and which version it is.

### FAQ

**Q: Are UUID v4 values truly random and safe to use as primary keys?**

A: Yes. UUID v4 uses a cryptographically secure random number generator (Node.js crypto.randomUUID(), which calls the OS CSPRNG). Two independently generated v4 UUIDs colliding is astronomically unlikely — roughly a 1 in 5.3×10³⁶ chance per pair. They are safe as primary keys in databases, session tokens, and correlation IDs.

**Q: What is the difference between UUID v1, v4, and v7?**

A: v1 encodes the MAC address and timestamp — sortable but exposes hardware identity. v4 is fully random — the most privacy-safe and widely supported. v7 (RFC 9562, 2024) encodes a millisecond-precision timestamp in the high bits so UUIDs sort chronologically, which improves database index locality. This tool generates v4. For v7, use a dedicated library like 'uuid' on npm.

**Q: Can I use a UUID without the hyphens?**

A: Yes. Hyphens are part of the canonical textual representation but carry no information — the 128-bit value is identical. The compact format (32 hex chars, no hyphens) is common in URLs, file names, and storage systems that require alphanumeric-only identifiers. Most UUID parsers accept both formats.

### Examples

**Generate one UUID v4**
```json
Input:  {
  "count": 1,
  "format": "hyphenated"
}
Output: {
  "uuids": [
    "550e8400-e29b-41d4-a716-446655440000"
  ],
  "count": 1,
  "format": "hyphenated"
}
```

**Generate 5 compact UUIDs**
```json
Input:  {
  "count": 5,
  "format": "compact"
}
Output: {
  "uuids": [
    "550e8400e29b41d4a716446655440000",
    "6ba7b810e29b11d1a71600c04fd430c8",
    "6ba7b811e29b11d1a71600c04fd430c8",
    "6ba7b812e29b11d1a71600c04fd430c8",
    "6ba7b814e29b11d1a71600c04fd430c8"
  ],
  "count": 5,
  "format": "compact"
}
```

**Validate a UUID**
```json
Input:  {
  "count": 1,
  "format": "hyphenated",
  "validate": "550e8400-e29b-41d4-a716-446655440000"
}
Output: {
  "uuids": [],
  "count": 0,
  "format": "hyphenated",
  "is_valid": true,
  "validated_version": "v4"
}
```

### Related tools

- https://quickhelp.dev/hash-generator
- https://quickhelp.dev/timestamp-converter

---

## Text Case Converter

**Slug**: `text-case-converter`
**Category**: text
**API**: POST https://quickhelp.dev/api/text-case-converter
**UI**: https://quickhelp.dev/text-case-converter

### Description

Convert any identifier or phrase between 11 naming conventions: camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, COBOL-CASE, dot.case, Title Case, Sentence case, lowercase, and UPPERCASE. Intelligently splits on whitespace, hyphens, underscores, dots, and camelCase boundaries so you can convert between any two formats in one step.

### What is it?

Naming conventions define how words are combined into identifiers in code, configuration files, APIs, and databases. camelCase (myVariable) is the standard in JavaScript and Java. snake_case (my_variable) is the norm in Python, Ruby, and SQL. kebab-case (my-variable) is used in CSS, HTML attributes, and URL slugs. PascalCase (MyVariable) is used for class names and React components across most languages. SCREAMING_SNAKE_CASE (MY_VARIABLE) marks constants. Different tools, frameworks, and languages enforce different conventions, so converting between them is a constant need when writing glue code, generating API clients, or adapting data from one system to another. This tool splits any identifier or phrase into its component words — intelligently handling camelCase boundaries, underscores, hyphens, and dots — then reassembles them in the target convention.

### How to use

1. **Paste the identifier or phrase**: Enter any identifier or multi-word phrase. The tool automatically splits on whitespace, underscores, hyphens, dots, and camelCase/PascalCase word boundaries — so you can convert from any format to any other in one step.

2. **Select the target case**: Choose from 11 naming conventions: camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, COBOL-CASE, dot.case, Title Case, Sentence case, lowercase, or UPPERCASE.

3. **Copy the result**: The converted identifier appears instantly. The 'tokens' field shows the words extracted from your input — useful for verifying the split was correct before using the output in code.

### FAQ

**Q: How does the tool split compound words like 'innerHTML' or 'XMLParser'?**

A: camelCase splitting uses two regex passes: first it inserts a space before any lowercase-to-uppercase transition (innerHTML → inner Html), then before any sequence of uppercase letters followed by an uppercase-then-lowercase transition (XMLParser → XML Parser). Both passes together correctly split 'XMLParser' into ['xml', 'parser'] and 'innerHTML' into ['inner', 'html'].

**Q: Does the tool preserve acronyms like 'URL' or 'HTTP'?**

A: Acronyms are lowercased as part of tokenisation and then recased according to the target convention. In camelCase, 'parseURL' becomes 'parseUrl'; in PascalCase it becomes 'ParseUrl'. If your codebase uses a style guide that keeps acronyms uppercase (e.g. 'parseURL'), apply the conversion and then manually restore the acronym casing.

**Q: Can I convert multiple identifiers at once?**

A: This tool converts one identifier per call. For bulk conversion in a script, use the REST API: POST /api/text-case-converter with each identifier. In Node.js, you can also use the 'change-case' npm package for programmatic bulk conversion.

### Examples

**camelCase to snake_case**
```json
Input:  {
  "input": "myVariableName",
  "to": "snake_case"
}
Output: {
  "output": "my_variable_name",
  "tokens": [
    "my",
    "variable",
    "name"
  ],
  "from_detected": "camelCase"
}
```

**snake_case to kebab-case**
```json
Input:  {
  "input": "my_variable_name",
  "to": "kebab-case"
}
Output: {
  "output": "my-variable-name",
  "tokens": [
    "my",
    "variable",
    "name"
  ],
  "from_detected": "snake_case"
}
```

**Phrase to PascalCase**
```json
Input:  {
  "input": "hello world example",
  "to": "PascalCase"
}
Output: {
  "output": "HelloWorldExample",
  "tokens": [
    "hello",
    "world",
    "example"
  ],
  "from_detected": "Sentence case"
}
```

### Related tools

- https://quickhelp.dev/json-formatter
- https://quickhelp.dev/url-encoder

---

## JSON to CSV Converter

**Slug**: `json-to-csv`
**Category**: formatting
**API**: POST https://quickhelp.dev/api/json-to-csv
**UI**: https://quickhelp.dev/json-to-csv

### Description

Convert a JSON array of objects to a comma-separated values (CSV) file with a header row, or parse a CSV string back to a JSON array. Handles nested objects by dot-notation flattening (e.g. address.city), quoted fields with embedded commas or newlines, and configurable delimiters (comma, semicolon, tab).

### What is it?

JSON (JavaScript Object Notation) and CSV (Comma-Separated Values) are the two most common formats for exchanging tabular data. JSON is the native format for REST APIs, NoSQL databases, and JavaScript applications. CSV is the native format for spreadsheet tools like Excel and Google Sheets, SQL import utilities, data pipelines, and business reporting tools. Converting between them is one of the most frequent data engineering tasks: you might export an API response to a spreadsheet for analysis, import a CSV upload into a database, or transform a data warehouse export into JSON for an API. This tool converts a JSON array of objects to a CSV with a header row derived from the object keys, or parses a CSV back to a JSON array. Nested objects are optionally flattened using dot-notation keys (address.city) so the entire structure fits into a flat table.

### How to use

1. **Paste your JSON array or CSV**: For JSON-to-CSV: paste a JSON array of objects (e.g. [{"name":"Alice","age":30}]). For CSV-to-JSON: paste a CSV string with a header row as the first line.

2. **Choose mode and delimiter**: Select 'json-to-csv' or 'csv-to-json'. Choose the field delimiter — comma is the universal default; semicolon is common in European locales where comma is the decimal separator; tab (TSV) is used by Excel exports and some databases.

3. **Copy the output**: The converted CSV or JSON appears instantly. For CSV output, paste it directly into a spreadsheet or save it as a .csv file. For JSON output, paste it into your application or use it in a script.

### FAQ

**Q: What happens to nested objects?**

A: With flatten enabled (the default), nested objects are expanded using dot-notation keys. For example, {address: {city: 'London'}} becomes a column named 'address.city'. With flatten disabled, the nested object is JSON-stringified and placed in a single cell.

**Q: What if my CSV values contain commas or newlines?**

A: The converter follows RFC 4180: values containing the delimiter, double quotes, or newlines are enclosed in double quotes, and any double quotes within the value are escaped as two consecutive double quotes. The CSV-to-JSON parser handles this correctly.

**Q: Does the JSON-to-CSV converter handle arrays of arrays or mixed types?**

A: The converter expects a JSON array of flat objects. Arrays of arrays are not tabular data and cannot be meaningfully converted to CSV. Mixed types (some rows have extra fields) are handled by taking the union of all keys across all rows and leaving cells empty where a field is absent.

### Examples

**JSON array to CSV**
```json
Input:  {
  "input": "[{\"name\":\"Alice\",\"age\":30,\"city\":\"London\"},{\"name\":\"Bob\",\"age\":25,\"city\":\"Paris\"}]",
  "mode": "json-to-csv",
  "delimiter": ",",
  "flatten": true
}
Output: {
  "output": "name,age,city\nAlice,30,London\nBob,25,Paris",
  "row_count": 2,
  "column_count": 3,
  "columns": [
    "name",
    "age",
    "city"
  ],
  "mode": "json-to-csv"
}
```

**CSV to JSON array**
```json
Input:  {
  "input": "name,age,city\nAlice,30,London\nBob,25,Paris",
  "mode": "csv-to-json",
  "delimiter": ",",
  "flatten": true
}
Output: {
  "output": "[{\"name\":\"Alice\",\"age\":\"30\",\"city\":\"London\"},{\"name\":\"Bob\",\"age\":\"25\",\"city\":\"Paris\"}]",
  "row_count": 2,
  "column_count": 3,
  "columns": [
    "name",
    "age",
    "city"
  ],
  "mode": "csv-to-json"
}
```

**Nested object flattening**
```json
Input:  {
  "input": "[{\"name\":\"Alice\",\"address\":{\"city\":\"London\",\"zip\":\"EC1A\"}}]",
  "mode": "json-to-csv",
  "delimiter": ",",
  "flatten": true
}
Output: {
  "output": "name,address.city,address.zip\nAlice,London,EC1A",
  "row_count": 1,
  "column_count": 3,
  "columns": [
    "name",
    "address.city",
    "address.zip"
  ],
  "mode": "json-to-csv"
}
```

### Related tools

- https://quickhelp.dev/json-formatter
- https://quickhelp.dev/text-case-converter

---

## Color Converter

**Slug**: `color-converter`
**Category**: conversion
**API**: POST https://quickhelp.dev/api/color-converter
**UI**: https://quickhelp.dev/color-converter

### Description

Convert any color between HEX (#rrggbb), RGB (r, g, b), HSL (hue, saturation, lightness), and HSV/HSB (hue, saturation, value) formats. Accepts HEX with or without the # prefix, shorthand HEX (#abc), rgb() function syntax, hsl() function syntax, or bare r,g,b values. Returns all four representations at once.

### What is it?

Colors in digital design and web development are represented in multiple formats, each suited to a different context. HEX (#ff6600) is the format used in CSS, HTML, and design tools like Figma and Photoshop. RGB (red, green, blue) is the native format of screens — each channel has a value from 0 to 255. HSL (hue, saturation, lightness) is the most human-readable format: you adjust hue to pick a colour family, saturation to move from grey to vivid, and lightness to go from black to white. HSV/HSB (hue, saturation, value/brightness) is used in colour pickers in design software and is similar to HSL but with different semantics for the third channel. Converting between formats is necessary when moving colours from a design tool (HEX or HSL) to CSS code (rgb()), from a colour picker (HSV) to a data attribute (HEX), or when programmatically generating palettes by rotating the hue in HSL.

### How to use

1. **Paste any colour value**: Enter the colour in any supported format: a HEX code with or without the # prefix (including shorthand #abc), an rgb() or hsl() CSS function string, or bare r,g,b values separated by commas.

2. **Read all four formats**: The converter returns HEX, RGB, HSL, and HSV simultaneously — no need to convert multiple times. The css field for RGB and HSL gives you the exact CSS function string ready to paste into a stylesheet.

3. **Copy the format you need**: Copy the HEX value for Figma or design tools, the rgb() or hsl() CSS string for stylesheets, or the individual HSL values when building a colour palette programmatically.

### FAQ

**Q: What is the difference between HSL and HSV?**

A: Both use hue and saturation, but the third channel differs. In HSL, lightness 0 is black and lightness 100 is white — fully saturated colours sit at lightness 50. In HSV, value 0 is black and value 100 is the full colour — to get white you reduce saturation, not value. Design software colour pickers typically use HSV; CSS uses HSL.

**Q: Does the tool support alpha / transparency?**

A: Not currently. This converter handles opaque colours only. For RGBA or HSLA, append the alpha channel manually to the CSS output: rgb(255, 102, 0) → rgba(255, 102, 0, 0.5).

**Q: Why does the HEX output look different from what Figma shows?**

A: Figma may show colour values in a colour profile other than sRGB (e.g. Display P3). If your design file uses a wide-gamut colour space, the HEX values are in P3 and will look different when converted to sRGB. Check your Figma document colour profile under File → Document Colours.

### Examples

**HEX to all formats**
```json
Input:  {
  "color": "#ff6600"
}
Output: {
  "hex": "#ff6600",
  "rgb": {
    "r": 255,
    "g": 102,
    "b": 0,
    "css": "rgb(255, 102, 0)"
  },
  "hsl": {
    "h": 24,
    "s": 100,
    "l": 50,
    "css": "hsl(24, 100%, 50%)"
  },
  "hsv": {
    "h": 24,
    "s": 100,
    "v": 100
  },
  "valid": true
}
```

**RGB to all formats**
```json
Input:  {
  "color": "rgb(30, 144, 255)"
}
Output: {
  "hex": "#1e90ff",
  "rgb": {
    "r": 30,
    "g": 144,
    "b": 255,
    "css": "rgb(30, 144, 255)"
  },
  "hsl": {
    "h": 210,
    "s": 100,
    "l": 56,
    "css": "hsl(210, 100%, 56%)"
  },
  "hsv": {
    "h": 210,
    "s": 88,
    "v": 100
  },
  "valid": true
}
```

**Shorthand HEX**
```json
Input:  {
  "color": "#abc"
}
Output: {
  "hex": "#aabbcc",
  "rgb": {
    "r": 170,
    "g": 187,
    "b": 204,
    "css": "rgb(170, 187, 204)"
  },
  "hsl": {
    "h": 210,
    "s": 25,
    "l": 73,
    "css": "hsl(210, 25%, 73%)"
  },
  "hsv": {
    "h": 210,
    "s": 17,
    "v": 80
  },
  "valid": true
}
```

### Related tools

- https://quickhelp.dev/image-converter
- https://quickhelp.dev/base64

---

## Number Base Converter

**Slug**: `number-base-converter`
**Category**: encoding
**API**: POST https://quickhelp.dev/api/number-base-converter
**UI**: https://quickhelp.dev/number-base-converter

### Description

Convert any integer between base 2 (binary), base 8 (octal), base 10 (decimal), and base 16 (hexadecimal). Returns all four representations at once, with grouped formats for readability. Supports arbitrarily large integers via BigInt.

### What is it?

The Number Base Converter converts integers between the four bases used in computing: binary (base 2), octal (base 8), decimal (base 10), and hexadecimal (base 16). Enter a number in any base and the tool returns all four representations instantly — no manual arithmetic required. It also returns a grouped binary format (4-digit nibbles) and grouped hex (2-digit bytes) for easier reading, the bit length of the value, and whether it is a power of two.

### How to use

1. **Enter your number**: Type the value in the Input field. For hexadecimal, use digits 0–9 and letters A–F (case-insensitive). The 0x prefix is optional.

2. **Select the input base**: Choose the base your number is in: Binary (base 2), Octal (base 8), Decimal (base 10), or Hexadecimal (base 16).

3. **Read all four outputs**: The result shows the value in all four bases simultaneously — decimal, binary, octal, and hexadecimal — along with grouped formats and bit length.

### FAQ

**Q: What is binary (base 2)?**

A: Binary is the native number system of computers. Every integer is represented using only the digits 0 and 1. Each digit position represents a power of 2: the rightmost is 2^0 (1), then 2^1 (2), 2^2 (4), 2^3 (8), and so on. The decimal number 10 is 1010 in binary (8 + 2).

**Q: What is hexadecimal (base 16) and why do developers use it?**

A: Hexadecimal uses 16 digits: 0–9 and A–F. Developers prefer hex because it maps cleanly to binary: each hex digit represents exactly 4 binary digits (a nibble). This makes hex a compact way to express binary values — the 8-bit byte 11111111 is simply FF in hex, and 32-bit memory addresses fit in 8 hex characters. CSS color values (#FF6600), file magic bytes, and network masks are all commonly expressed in hex.

**Q: What is octal (base 8) used for?**

A: Octal uses digits 0–7. It is most commonly encountered in Unix file permission modes: chmod 755 means owner can read/write/execute (7 = 111 in binary), group can read/execute (5 = 101), others can read/execute (5 = 101). Octal also appears in older C codebases and network protocols. Each octal digit represents exactly 3 binary digits.

**Q: Does this tool handle large numbers?**

A: Yes. The converter uses JavaScript's BigInt internally, so it handles arbitrarily large integers without precision loss — unlike Number, which loses precision above 2^53. You can convert a 256-bit integer accurately.

**Q: How do I convert a hex color code to decimal RGB values?**

A: A CSS hex color like #FF6600 has three 2-digit hex components: R=FF, G=66, B=00. Convert each pair to decimal: FF → 255, 66 → 102, 00 → 0. The result is rgb(255, 102, 0). Use this tool for each pair, or use the Color Converter tool which handles full CSS color conversions.

### Examples

**Decimal 255 to all bases**
```json
Input:  {
  "input": "255",
  "from_base": 10
}
Output: {
  "input_normalized": "255",
  "from_base": 10,
  "decimal": "255",
  "binary": "11111111",
  "octal": "377",
  "hexadecimal": "FF",
  "binary_grouped": "1111 1111",
  "hex_grouped": "FF",
  "bit_length": 8,
  "is_power_of_two": false
}
```

**Hex FF to all bases**
```json
Input:  {
  "input": "FF",
  "from_base": 16
}
Output: {
  "input_normalized": "FF",
  "from_base": 16,
  "decimal": "255",
  "binary": "11111111",
  "octal": "377",
  "hexadecimal": "FF",
  "binary_grouped": "1111 1111",
  "hex_grouped": "FF",
  "bit_length": 8,
  "is_power_of_two": false
}
```

### Related tools

- https://quickhelp.dev/hash-generator
- https://quickhelp.dev/color-converter
- https://quickhelp.dev/base64
- https://quickhelp.dev/url-encoder

---