conversion

Convert a curl command into equivalent JavaScript, Python, Node.js, PHP, or Go code.

Convert a Postman Collection into an OpenAPI 3.0.3 document.

Convert an OpenAPI 3.x or Swagger 2.0 spec into a Postman Collection v2.1.

Convert a single Postman request-item JSON into an equivalent curl command.

Suggest heuristic REST verb+path mappings for a GraphQL query or mutation's top-level fields.

Convert a curl command into a Postman request-item JSON object.

Decode space-separated character codes in any base from 2 to 36 back into strict 7-bit ASCII text.

Convert strict 7-bit ASCII text to space-separated character codes in any base from 2 to 36.

Convert ASCII text to Atari ATASCII hex byte values, mapping newline to ATASCII's 0x9B EOL byte.

Base64-encode strict 7-bit ASCII text directly, with no UTF-8 conversion step needed.

Convert each ASCII character's decimal code to three BCD nibbles, this site's documented convention.

Convert strict 7-bit ASCII text to space-separated 8-bit binary, one group per character.

Convert printable ASCII text to IBM EBCDIC code page 037 (CP037) hex byte values.

Convert ASCII characters to their legacy JS KeyboardEvent.keyCode numeric values, US QWERTY.

Convert strict 7-bit ASCII text to space-separated 3-digit octal, one group per character.

Convert ASCII text to Commodore 64 unshifted PETSCII hex byte values.

Convert ASCII text to real PS/2 Set 1 keyboard make-scan-codes, US QWERTY layout.

Convert strict 7-bit ASCII text to space-separated U+00XX Unicode code point notation.

Decode Atari ATASCII hex byte values back into ASCII text, mapping 0x9B back to a newline.

Decode Base64 and strictly validate that every resulting byte is 7-bit ASCII.

Decode this site's 3-nibble hyphenated BCD segments back into ASCII text.

Decode space-separated 7-or-8-bit binary groups back into strict 7-bit ASCII text.

Decode IBM EBCDIC code page 037 (CP037) hex byte values back into printable ASCII text.

Decode legacy JS KeyboardEvent.keyCode numbers back into (uppercase) ASCII text.

Decode space-separated octal groups back into strict 7-bit ASCII text.

Decode Commodore 64 unshifted PETSCII hex byte values back into (uppercase) ASCII text.

Decode PS/2 Set 1 keyboard make-scan-codes, including the 2A shift prefix, back into ASCII text.

Decode space-separated U+XXXX Unicode code points back into strict 7-bit ASCII text.

Convert a simple SQL SELECT statement into an equivalent MongoDB-style find() query.

Convert pasted HTML markup into equivalent JSX, with class/for renamed and attributes camelCased.

Convert simple JSX markup into plain HTML, with className/htmlFor renamed and style objects inlined.

Convert plain CSS rules into their closest Tailwind CSS utility class equivalents.

Convert a space-separated list of Tailwind utility classes into equivalent plain CSS declarations.

Convert plain ASCII text to space-separated uppercase hex bytes, one pair per character.

Convert a big-endian hex value into its little-endian byte order.

Repeat every digit of a hex value a set number of times in place.

Pull out a single hex digit from a value by its 0-based position, counted from the left.

Reverse the byte order of a hex string, swapping between little-endian and big-endian layout.

Reverse the order of a hex value's individual digits, distinct from byte-level endianness swaps.

Deterministically rotate the individual hex digits of a value by a chosen number of positions.

Randomly shuffle the individual hex digits of a value using cryptographically secure randomness.

Flip every bit of a hexadecimal number, a quick way to compute its bitwise complement.

Combine a list of hex numbers, one per line or space-separated, into a single hex string.

Decode space-separated or contiguous hex bytes back into 7-bit ASCII text.

Turn 8 raw hex digits into a readable dotted-quad IPv4 address like 192.168.1.1.

Turn 32 raw hex digits into a colon-separated IPv6 address, plus its RFC 5952 compressed form.

Decode hex bytes as UTF-8 text, correctly handling multi-byte characters and invalid sequences.

Convert a dotted-quad IPv4 address like 192.168.1.1 into its raw 8-digit hex value.

Expand a full or compressed IPv6 address into its raw 32-hex-digit representation.

Convert a little-endian hex value into its big-endian byte order.

Encode any Unicode text as its real UTF-8 byte sequence, formatted as hex.

Decode Bencode text (the format BitTorrent .torrent files use) into JSON.

Decode hex-encoded BSON bytes back into a readable JSON document.

Parse a CSON (CoffeeScript Object Notation) document's indented blocks and inline arrays into JSON.

Convert CSV rows into a JSON array of objects, using the header row as keys.

Decode a data:application/json;base64,... (or percent-encoded) URI back into pretty-printed JSON.

Parse application/x-www-form-urlencoded text, including bracket-path field names, into nested JSON.

Parse INI text (sections, key=value lines, comments) into a JSON object.

Convert single-quoted JS-object-literal-like text back into valid double-quoted JSON.

Best-effort repair of single-quoted, curly-quoted, or unquoted-key JSON-like text into valid JSON.

Replace every structural double quote in pretty-printed JSON with a single quote.

Convert valid JSON into relaxed JS-object-literal syntax with unquoted identifier keys.

Encode a JSON value as Bencode, the encoding BitTorrent .torrent files use.

Encode a JSON object as BSON, the binary format MongoDB uses on the wire.

Render a JSON object as CSON (CoffeeScript Object Notation): indented blocks, bare keys, inline scalar arrays.

Convert a JSON array of objects into CSV.

Flatten a JSON object into application/x-www-form-urlencoded text with bracket-path keys.

Render JSON as semantic HTML: objects become definition lists, arrays become unordered lists.

Convert a JSON object into classic INI format with sections and key=value lines.

Convert a JSON array into JSON Lines (JSONL): one compact JSON value per line.

Render a JSON array of objects as a LaTeX tabular table, ready to paste into a document.

Convert a JSON array into a plain line-by-line list, no brackets, quotes, or commas.

Serialize JSON into a Lua table literal, the exact inverse of the Lua to JSON Table parser.

Encode JSON as hex-dumped MessagePack using the smallest fixed-size encoding for every value.

Render JSON as a PHP array literal using modern short-array syntax, ready to paste into PHP source.

Flatten JSON into dot-notation key=value lines (Java .properties format).

Encode JSON as protobuf wire-format bytes without a .proto schema, with a field-number legend.

Turn JSON into an indented, punctuation-free plain-text outline.

Convert a JSON object into a TOML document with tables and array-of-tables.

Convert JSON to TOON, a compact format designed to use fewer LLM tokens.

Flatten a JSON array into tab-separated rows.

Encode a JSON value as UBJSON (Universal Binary JSON), shown as a hex dump.

Convert JSON data into well-formed XML markup.

Convert JSON into clean, block-style YAML.

Parse JSON Lines (JSONL/NDJSON) text, one JSON value per line, into a single JSON array.

Convert a plain newline-separated list into a pretty-printed JSON array of strings.

Parse a Lua table literal into equivalent JSON.

Decode hex-encoded MessagePack bytes back into readable JSON.

Parse a PHP array literal (short [...] or array(...) syntax) into JSON.

Parse a Java .properties file into nested JSON.

Decode hex-encoded protobuf bytes into JSON with generic field1, field2 labels, no schema needed.

Split raw text by a delimiter into a JSON array of trimmed, non-empty strings.

Parse a TOML document (tables and array-of-tables included) into JSON.

Convert tab-separated rows into a JSON array of objects, using the header row as keys.

Decode hex-encoded UBJSON (Universal Binary JSON) bytes back into JSON.

Convert an XML document into equivalent JSON.

Convert a YAML document into equivalent, pretty-printed JSON.

Convert Markdown into clean, semantic HTML.

Convert HTML into clean Markdown you can edit as plain text.

Strip Markdown syntax down to plain, readable text.

Parse a Markdown pipe table into JSON objects or CSV rows, with per-column alignment.

Render Markdown, then save it as a PDF through your browser's print dialog.

Extract a Markdown document's frontmatter and heading structure into YAML.

Live split-pane Markdown editor with a rendered/HTML-source toggle and one-click PDF export.

Convert Markdown into a real, downloadable .docx file, built entirely in your browser.

Convert standard Markdown into the formatting Slack and Microsoft Teams messages actually support.

Convert a dotted-quad IPv4 address into its 32-bit unsigned integer form.

Convert a 32-bit unsigned integer back into a dotted-quad IPv4 address.

Convert an IPv4 address into its IPv4-mapped IPv6 form.

Extract the embedded IPv4 address from an IPv4-mapped, 6to4, or NAT64 IPv6 address.

Convert a start/end IPv4 range into the minimal list of CIDR blocks that cover it exactly.

Decode space-separated ASCII codes back into text.

Wrap BBCode markup as a quoted, escaped string literal.

Decode space-separated binary code points back into text.

Decode space-separated UTF-8 byte values back into text.

Wrap CSV text as a quoted, escaped string literal.

Decode space-separated decimal Unicode code points back into text.

Convert space-separated numbers 1-26 back to their letters.

Convert standalone digit numbers (0-999) in text to spelled-out words.

Decode space-separated hexadecimal code points back into text.

Wrap HTML markup as a quoted, escaped string literal.

Decode a quoted JSON string literal back to its original text.

Validate JSON, then wrap it as a quoted, escaped string literal.

Validate JSON and collapse it to a single-line string.

Convert each letter to its 1-based alphabet position number (a=1 ... z=26).

Convert spelled-out English numbers (0-999) in text to digit form.

Decode space-separated octal code points back into text.

Convert ASCII-only text to space-separated decimal ASCII codes.

Convert text to space-separated 8-bit binary code points.

Convert text to its actual UTF-8 byte values, space-separated.

Unwrap a quoted string literal back into raw CSV text.

Convert text to space-separated decimal Unicode code points.

Convert text to space-separated 2-digit hexadecimal code points.

Convert text to space-separated 3-digit octal code points.

Wrap XML markup as a quoted, escaped string literal.

Detect whether pasted CSV-like text uses commas, semicolons, tabs, or pipes, and normalize it to commas.

Convert CSV rows into TOON's compact tabular array syntax, designed to use fewer LLM tokens than JSON.

Left-join two CSVs on a shared key column, or extract just the columns you need from one CSV.

Highlight XML syntax and export it as portable, self-contained HTML.

Render syntax-highlighted XML as a downloadable PNG image.

Convert XML into equivalent, pretty-printed JSON.

Convert JSON into indented, well-formed XML with a custom root element.

Flatten XML records into comma-separated CSV rows.

Convert CSV rows into a well-formed XML document.

Convert XML into clean, indented YAML.

Convert YAML into indented, well-formed XML with a custom root element.

Flatten XML records into tab-separated TSV rows.

Convert tab-separated TSV rows into a well-formed XML document.

Validate XML, then Base64-encode its raw bytes.

Decode Base64 back to UTF-8 text and pretty-print it as XML.

Validate XML, then percent-encode it for safe use in a URL.

Percent-decode a URL-encoded value, then pretty-print it as XML.

Extract plain text from XML, stripping all tags, attributes, and comments.

Render XML's repeated elements as an actual HTML table, columns and rows, not just text.

Collapse a nested XML document into a flat list of dot/bracket-path keys and values.

Convert XML into Java-style .properties key=value lines.

Convert Java-style .properties key=value lines into a well-formed XML document.

Convert XML into classic INI format: [section] headers and key=value lines.

Convert classic INI text ([section] headers, key=value lines) into a well-formed XML document.

Convert XML into TOML: key = value lines, [section] tables, and [[section]] array-of-tables.

Convert TOML (key = value, [section] tables, [[section]] array-of-tables) into a well-formed XML document.

Wrap an XML document as a data: URI you can embed directly in HTML, CSS, or a config value.

Decode a data:application/xml;base64,... URI (or a bare Base64 string) back into readable XML.

Convert XML into a ready-to-paste PHP array literal using modern short-array syntax.

Turn repeated XML elements into one INSERT INTO statement per row.

Turn INSERT INTO ... VALUES (...) statements into XML rows.

Convert XML into Bencode, the encoding BitTorrent .torrent files use.

Decode Bencode (the BitTorrent encoding) into readable, well-formed XML.

Encode XML as this site's own compact binary tree format, shown as hex.

Decode this site's compact binary XML (hex) format back into readable, well-formed XML.

Convert XML into BSON, the binary document format MongoDB uses, shown as hex.

Decode hex-encoded BSON (MongoDB's binary document format) into readable XML.

Turn repeated XML elements into an Excel-openable spreadsheet file.

Convert spreadsheet text (pasted cells, or CSV exported from Excel) into a well-formed XML document.

Render pretty-printed XML and save it as a PDF using your browser's print dialog.

Convert XML into minified, single-line JSON.

Parse a PHP array literal ([...] or array(...)) and convert it into well-formed XML.

Convert HTML into well-formed XML: void elements self-close, attributes get quoted, text gets escaped.

Turn JSON into clean, readable YAML.

Convert a CSV table into a YAML list of records.

Convert classic [section]-based INI files into nested YAML.

Convert .env-style KEY=value lines into a flat YAML mapping.

Convert HCL blocks and attributes (a Terraform-style config subset) into nested YAML.

Convert HOCON (Typesafe Config) key/value pairs and dot-paths into nested YAML.

Convert a CREATE TABLE statement into a YAML table/column schema description.

Convert simple, well-formed HTML into a YAML tree of tag/attributes/children/text nodes.

Convert YAML into TOON, a compact, indentation-based, LLM-token-efficient format.

Parse NestedText's key/list/multiline syntax into nested YAML.

Rebuild nested YAML from flat Java-style key=value .properties lines.

Convert TOML tables and arrays of tables into nested YAML.

Convert tab-separated values into a YAML list of records.

Convert XML documents into readable YAML.

Collapse nested YAML mappings and sequences into flat dot-notation keys.

Convert a YAML list of records into a CSV table.

Convert YAML documents into properly formatted JSON.

Convert YAML into NestedText's minimal, everything-is-a-string format.

Format and syntax-highlight YAML, then print or save it as a PDF.

Turn YAML into a ready-to-paste PHP array literal with proper quoting and escaping.

Flatten YAML into Java-style key=value .properties lines.

Convert YAML into TOML's table and array-of-tables syntax.

Convert a YAML list of records into tab-separated values.

Convert YAML documents into indented XML.

Rename a mapping key to a new name everywhere it appears in a YAML document.

Replace every leaf scalar value that exactly matches a query with a new value.

Paste a PHP array literal and get back the equivalent YAML document.

Decode a list of space-separated binary bytes back into UTF-8 text, item by item.

Join list items into a single string using a configurable glue, like Array.prototype.join(), e.g. " | " turns a, b, c into a | b | c.

Parse a list using one separator and rejoin it using a different one, e.g. newline-separated to comma-separated.

Remove the separators entirely, concatenating every list item directly together into one unbroken blob.

Build a real downloadable .xlsx spreadsheet with one list item per row in column A.

Wrap list items as an HTML <ul> or <ol> list, with each item as an escaped <li>.

Render your list as monospace text lines on a canvas and download it as a PNG.

Wrap list items as a LaTeX itemize environment, escaping LaTeX's reserved characters automatically.

Prefix list items as a Markdown list, with an Unordered (- ) or Ordered (1., 2., ...) toggle.

Build a real downloadable .pdf with one list item per line of text, using a hand-rolled minimal PDF writer.

Wrap list items as <list><item>a</item><item>b</item></list>, escaping XML's special characters.

Convert a plain list into a YAML block sequence, quoting items that need it.

Convert every item in a list to its UTF-8 binary representation, byte by byte.

Parse simple <item>...</item> elements (or any single repeated tag, auto-detected) out of pasted XML into a plain list.

Parse a flat YAML block sequence back into a plain list with your choice of separator.

Convert space-separated Binary-Coded Decimal nibbles back to a binary number.

Decode space-separated 4-bit BCD nibbles back into a plain decimal number.

Decode space-separated 4-bit BCD nibbles back into an octal value.

Convert a big-endian binary string to little-endian order by reversing its byte sequence.

Color-code every individual bit of a single binary number: one color for 1s, another for 0s.

Extract a contiguous bit field (e.g. bits 4-7) from a binary string by start index and length.

Circularly rotate the bits of a binary string left or right by a configurable amount.

Swap the bits at two chosen positions in a binary string, leaving every other bit unchanged.

Duplicate every individual bit in an 8-bit-aligned binary string, doubling each byte's length.

Color a list of binary numbers, one per line, each with its own distinct swatch.

Analyze a binary string: bit length, count of 1s/0s, longest run, byte alignment, and unsigned decimal value.

Reverse the BYTE order of a multi-byte binary string, leaving each byte's own bits intact.

Upload any file and see every byte rendered as 8-bit binary, grouped hexdump-style.

Flip every bit of a binary string: every 0 becomes a 1 and every 1 becomes a 0.

Join multiple binary values (one per line, or comma-separated) into one continuous string with a chosen separator.

Circularly rotate a binary value's bits to the left by a chosen amount.

Logically shift a binary string's bits left by N positions, zero-filling the right and dropping overflow on the left.

Pad a binary string to a target length with a chosen bit, on the left or right.

Find every occurrence of a bit sub-sequence in a binary string and replace it with another sequence.

Reverse the order of the characters in a binary string, without changing any bit's value.

Circularly rotate a binary value's bits to the right by a chosen amount.

Logically shift a binary string's bits right by N positions, zero-filling the left and dropping overflow on the right.

Decode run-length-encoded count-bit tokens like '3x1 5x0 2x1' back into a binary string.

Run-length encode a binary string into count-bit tokens like '3x1 5x0 2x1'.

Extract a substring of binary digits using start/end index slicing, with negative index support.

Spell a binary number out loud in words, one word per digit, e.g. '101' becomes 'one zero one'.

Split one binary string into equal-size chunks by chunk size or by chunk count, one per line.

Convert a binary number to any target base from 2 to 36 using exact BigInt arithmetic.

Convert a binary number to Binary-Coded Decimal, one 4-bit nibble per digit.

Decode 8-bit binary bytes back into text using the IBM EBCDIC (CP037) code page.

Decode a 32-bit IEEE 754 single-precision binary string back into its decimal value.

Convert a binary string directly to its reflected binary Gray code equivalent.

Convert 32 bits of binary back into a readable IPv4 dotted-quad address.

Reconstruct an IPv6 address from 128 bits (8 groups of 16).

Convert an ordinary binary number to negabinary (base -2) using exact BigInt arithmetic.

Convert binary numbers to octal, precisely, even for arbitrarily long values.

Convert a binary number to a standard Roman numeral (values 1-3999 only).

Convert a binary (base 2) number to ternary (base 3) using exact BigInt arithmetic.

Decode space-separated 8-bit binary octets as a UTF-8 byte sequence back into text.

Truncate a binary string to a maximum length, cutting from the left or the right.

Turn binary digits into an actual, downloadable monochrome .bmp file with correct BMP headers.

Pack a string of user-supplied binary digits into bytes and download the result as a .bin file.

Upload an image and reduce every pixel to a single bit, concatenated into one binary string.

Group a raw bit string into space-separated 8-bit bytes, padding the final byte if needed.

Validate space-separated 8-bit bytes and concatenate them into one continuous bit string.

Encode each digit of a decimal number as its own 4-bit BCD nibble.

Convert a decimal integer to its Gray code (reflected binary code) representation.

Convert printable ASCII text into its IBM EBCDIC (CP037) binary byte representation.

Convert a decimal number into its exact IEEE 754 single-precision (32-bit) binary layout.

Decode a reflected binary Gray code string back to ordinary binary.

Convert a Gray code (reflected binary) value back to its decimal integer equivalent.

Decode a Gray code value (in binary digits) back to its octal equivalent.

Convert an IPv4 dotted-quad address into its 32-bit binary representation.

Convert a full IPv6 address, including :: zero-compression, into its 128-bit binary form.

Convert a little-endian binary string to big-endian order by reversing its byte sequence.

Decode a two's-complement binary string to its signed decimal value.

Encode a signed decimal integer into two's-complement binary at a bit width you choose.

Convert an octal value to Binary-Coded Decimal, one 4-bit nibble per decimal digit.

Convert octal numbers to binary, precisely, even for arbitrarily long values.

Convert an octal number to its Gray code equivalent, expressed as binary digits.

Convert a standard Roman numeral to its binary representation.

Convert a ternary (base 3) number to binary (base 2) using exact BigInt arithmetic.

Encode text as its real UTF-8 byte sequence, shown as 8-bit binary octets.