Hash Text

Generate cryptographic hashes from any text

Choose an algorithm (MD5, SHA family, SHA3, RIPEMD160) and copy the digest instantly

Last updated: January 22, 2026

CreatorFrank Zhao

Hash text

Digest encoding

Plain text

Results

MD5

d41d8cd98f00b204e9800998ecf8427e

SHA-1

da39a3ee5e6b4b0d3255bfef95601890afd80709

SHA-256

e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

SHA-224

d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f

SHA-512

cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e

SHA-384

38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b

SHA-3

0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e

RIPEMD-160

9c1185a5c5e9fc54612808977ee8f548b2258d31

Introduction / Overview

A hash turns any text into a fixed-format fingerprint (also called a digest). It is designed to be fast to compute and extremely hard to reverse. This tool computes popular digests like MD5, SHA-1, SHA-2 (SHA-224/256/384/512), SHA-3, and RIPEMD-160.

You might use it to compare two texts, verify file integrity, create cache keys, or prepare values for systems that expect a digest. Conceptually, you can think of it as:

\text{digest} = H(\text{text})

Who is this for?

Developers debugging APIs, signatures, or cache keys
Analysts comparing identifiers across systems
Anyone verifying that two strings are identical

A quick reliability note

Digests here are computed locally in your browser. If you enable “share with results”, the plaintext may be included in the URL. For sensitive inputs (passwords, API keys, secrets), it’s safer to avoid sharing results.

If you need secure random strings (instead of hashing text), pair this with our Token Generator.

How to Use / Quick Start

1
Paste or type the text you want to hash.
2
Pick a digest encoding (Hex, Base64, Base64URL, or Binary).
3
Read the 8 results below — each algorithm appears on its own row.
4
Click the copy icon on the right to copy a specific digest.

Example A: conceptual calculation

Let your input be the string $m = \text{"hello"}$ . The tool computes a digest for each algorithm:

d = H(m)

=

H(\text{"hello"})

Since different hash functions use different internal rules, the resulting digests are different — that’s why showing all 8 is helpful.

Example B: switching output encoding

The underlying digest is a sequence of bytes. “Encoding” is just how those bytes are displayed. You can think of the same digest bytes $b$ being represented as:

Hex: $\text{hex}(b)$
Base64: $\text{base64}(b)$
Binary: $\text{bin}(b)$ (a readable bit-string)

If you’re matching a system output, the most common mismatch is the encoding, not the algorithm.

Real-World Examples / Use Cases

Comparing two inputs safely

Background: You want to confirm two strings are identical without eyeballing them.

Inputs: $m_1 = \text{"order-123"}$ and $m_2 = \text{"order-123"}$ .

H(m_1)

=

H(m_2)

\Rightarrow

m_1 = m_2\ \text{(with extremely high confidence)}

How to use the result: If the digests match (same algorithm + encoding), the inputs match.

Building a stable cache key

Background: You cache an API response keyed by a long query string.

Input: $m = \text{"/search?q=indigo+hoodiesort=price"}$ .

Result concept: $k = \text{SHA-256}(m)$ .

How to use the result: Use $k$ as the cache key instead of the full string.

Checking file integrity (string-based)

Background: A system gives you an expected hash for content.

Input: the file contents (as text) pasted into this tool.

Result concept: $\text{expected} = H(m)$

How to use the result: Compare your computed digest to the expected value.

Making URL-safe digests

Background: You want to embed a digest in a URL or filename.

Setting: choose Base64URL encoding.

Result concept: $u = \text{base64url}(H(m))$ .

How to use the result: Base64URL avoids characters that often need escaping.

Small but important: algorithm choice

For security-sensitive work (like password hashing), using the right approach matters. General-purpose digests like MD5 or SHA-1 are not recommended for new security designs. If you’re unsure, treat this tool as a compatibility and debugging utility.

Common Scenarios / When to Use

Comparing IDs

Confirm two identifiers match without staring at long strings.

API debugging

Reproduce a server digest locally to find mismatched settings.

URL-safe output

Use Base64URL when you need fewer reserved characters.

Binary inspection

Switch to Binary to visualize bits for teaching or debugging.

Legacy support

Match older systems that still rely on MD5 or SHA-1 outputs.

Cache keys

Shorten long inputs into stable keys using SHA-256 or SHA-512.

When it may not be appropriate

Password storage or authentication: use slow, salted password hashing (specialized tools), not a fast digest.
“Encrypting” secrets: hashing is not encryption and cannot be reversed.
Extremely large inputs: browsers can struggle with huge pastes; hashing large files is better done with dedicated tools.

Tips & Best Practices

Always confirm you’re matching both the algorithm and the encoding.
If a digest doesn’t match, check for hidden differences like newlines, spaces, and character casing.
For URLs and filenames, Base64URL is often easier than Base64.
Don’t treat a digest as “secure storage” for secrets; hashes can often be guessed via dictionaries.

If what you really need is a random secret (not derived from input text), use our Token Generator.

Calculation Method / Formula Explanation

A hash function maps an input message to a fixed-size output. We can describe this as:

H:\{0,1\}^* \rightarrow \{0,1\}^n

Where $m \in \{0,1\}^*$ is an arbitrary-length message and the digest is $n$ bits. For example, SHA-256 outputs $n = 256$ bits.

In this tool, “Digest encoding” converts digest bytes into a readable string format. Conceptually:

\text{shown}

=

\text{encode}(H(m))

=

\text{hex}(H(m))\ \text{or}\ \text{base64}(H(m))

The digest is the same underlying value; different encodings just change how it is represented.

About collisions (plain-English)

A “collision” means two different inputs have the same digest. Good modern algorithms make collisions extremely unlikely for typical use. Older ones (especially MD5 and SHA-1) have known weaknesses, so they should be used only for legacy compatibility.

Related Concepts / Background Info

Hash vs encryption vs encoding

Hashing: one-way fingerprint, written as $H(m)$ .
Encryption: reversible with a key, written as $E_k(m)$ .
Encoding: just a representation change, written as $\text{encode}(b)$ .

Most confusion comes from mixing these ideas. This tool focuses on hashing (and displaying the result in different encodings).

Why hashes are useful for integrity

If you have an expected digest and you compute the same digest from your input, the input likely hasn’t changed. Conceptually: $H(m) = d\ \Rightarrow\ \text{match}$

Frequently Asked Questions (FAQs)

Why do I see different results between tools?

The most common reasons are: different algorithm, different output encoding (Hex vs Base64), or hidden characters in the input (like a trailing newline). Make sure you’re comparing the same $H$ and the same encoding.

Is hashing the same as encryption?

No. Hashing is one-way: $d = H(m)$ . Encryption is reversible with a key: $c = E_k(m)$ and $m = D_k(c)$ .

Which algorithm should I pick?

For modern general use, SHA-256 is a solid default. Use MD5 or SHA-1 only if you must match a legacy system. SHA-512 can be useful when you need a longer digest.

What does Base64URL mean?

Base64URL is a URL-safe variant of Base64. It replaces characters that can be awkward in URLs and removes padding. Conceptually it’s still $\text{base64}(b)$ but with URL-safe substitutions.

Can I hash a password here and store it?

It’s not recommended. Password storage should use a slow, salted password hashing algorithm designed for that purpose. Fast digests like $\text{SHA-256}$ are easy to brute-force with dictionaries.

What does it mean if two hashes match?

If the algorithm and encoding are the same and you see $H(m_1) = H(m_2)$ , then it is overwhelmingly likely that $m_1 = m_2$ . In practice, people treat a match as “identical.”

Why does Binary output look extremely long?

Binary displays the digest at the bit level. For SHA-256, the output length is $256$ bits, so you’ll see a 256-character bit string.

Limitations / Disclaimers

This tool is for convenience and education; it does not replace security engineering advice.
Hash functions can be misused. Do not assume “hashed” means “safe”.
If you enable sharing with results, your plaintext may appear in the share URL.

External References / Sources

If you want deeper background on algorithms and security recommendations, these are good starting points:

Related tools

Need secure random values rather than hashes? Use our Token Generator.

Related Calculators

Chronometer

Use a simple chronometer (stopwatch) to track elapsed time down to milliseconds. Runs locally in your browser.

Try Now

Email normalizer

Normalize email addresses to a standard format for easier comparison. Useful for deduplication and data cleaning. Runs locally in your browser.

Try Now

ETA calculator

Estimate the time needed to consume a total amount at a constant rate, and get an expected end time. Runs locally in your browser.

Try Now

JWT parser

Parse and decode your JSON Web Token (JWT) and display its content. All computation runs locally in your browser.

Try Now

MIME types

Know which file extensions are associated to a MIME type, and which MIME type is associated to a file extension. Includes a full MIME types table.

Try Now

Lorem ipsum generator

Generate random Lorem Ipsum placeholder text with customizable paragraphs, sentences, and word counts. Runs locally in your browser.

Try Now