# SHA3-512 Hash Generator

> Use this SHA3-512 hash generator to hash text or encoded bytes. Calculate a SHA3-512 checksum or HMAC-SHA3-512 and copy the result in hex or Base64.

This **SHA3-512 hash generator** converts text or encoded bytes into a 512-bit digest in hex or Base64. Check a SHA3-512 checksum from another implementation, prepare a test vector, or enable HMAC to calculate a keyed message authentication code.

## Overview & Metadata

- **Canonical URL:** https://million.tools/sha3-512/
- **Markdown Copy (.md.txt):** https://million.tools/sha3-512.md.txt
- **Plain Text Copy (.txt):** https://million.tools/sha3-512.txt
- **SEO Title:** SHA3-512 Hash Generator Online | Hex, Base64 & HMAC
- **Alternative Names:** SHA3-512 Calculator, SHA3-512 Digest, SHA3-512 online, SHA3-512 checksum, HMAC-SHA3-512
- **Category:** [Hash](https://million.tools/hash/)
- **Tags:** [#SHA3](https://million.tools/tag/sha3/)
- **Application Category:** `DeveloperApplication`
- **Platform:** Web (All modern desktop and mobile browsers, requires JavaScript)
- **Price:** Free ($0.00 USD, no registration or sign-up required)
- **Live Calculation:** Supported (`Auto / Live` toggle enabled by default)
- **Usage Statistics:** 5 uses · 20 views
- **Published:** 2026-11-03
- **Last Updated:** 2026-11-03
- **Author:** Egor Volchenko (Developer & Author)

## Key Features

- Calculate SHA3-512 digests
- Interpret input as UTF-8 text, Hex bytes, or Base64-encoded bytes
- Select additional text encodings through Input Encoding:
- Display results as Hex (lower), Hex (UPPER), or Base64
- Update input results with Auto / Live or calculate with Run
- Copy results and clear entered text
- Calculate HMAC-SHA3-512 with HMAC Secret Key and a selectable key encoding

## Parameters & Interface Controls

### Input Parameters & Options
- `input_text`: Input text.
- `hmac_key`: HMAC Secret Key.
- `input_encoding`: `Hex` | `Hex (Ignore Non-Hex Characters)` | `Base64` | `UTF-8` | `UTF-16LE` | `UTF-16BE` | `Windows-1251 (Cyrillic)` | `Windows-1252 (Latin 1)` | ... (42 options)
- `output_format`: `Hex (lower)` | `Hex (UPPER)` | `Base64`
- `hmac_enabled`: Boolean. Enable HMAC-SHA3-512.
- `hmac_encoding`: `Hex` | `Hex (Ignore Non-Hex Characters)` | `Base64` | `UTF-8` | `UTF-16LE` | `UTF-16BE` | `Windows-1251 (Cyrillic)` | `Windows-1252 (Latin 1)` | ... (42 options)

### Output Fields & Metrics
- `result`: SHA3-512 Hash Result.

- **Controls:** `Run`, `Clear`, `Copy`, `Fill test data`, `Auto / Live`

## Interactive Example (Test Vector)

**Settings:**
- Input Encoding: `Hex`
- Output Format: `Hex (lower)`
- Key Encoding (Search/Type): `UTF-8`

**Input text:**
```text
616263
```

**SHA3-512 Hash Result:**
```text
b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0
```

## How to calculate a SHA3-512 digest

### Generate a digest from your message

Choose the input encoding that matches your message, then compare the result in the format your application expects.

1. Type or paste your message into *Input text*. Keep any spaces and line breaks that belong to the data.
2. Under *Input Encoding:*, choose UTF-8 for ordinary text, Hex for hexadecimal bytes, or Base64 for Base64-encoded bytes.
3. Leave *Enable HMAC-SHA3_512* off for a plain digest. For a keyed result, enable it and set *HMAC Secret Key* and *Key Encoding (Search/Type):* as described below.
4. Select *Hex (lower)*, *Hex (UPPER)*, or *Base64* in the output options.
5. Keep *Auto / Live* on to update the result as you edit the input, or turn it off and click *Run* when ready.
6. Read *SHA3-512 Hash Result* and click *Copy* to copy the result. To start over, use *Clear* where shown or the input field’s clear control.

For a quick check, enter `abc` with *Input Encoding:* set to UTF-8 and HMAC off. Select *Hex (lower)*. The result is `b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0`.

### Authenticate a message with HMAC-SHA3-512

Use this mode when your application expects a message authentication code calculated with a shared secret.

1. Turn on *Enable HMAC-SHA3_512* to reveal the key settings.
2. Enter your test key in *HMAC Secret Key*. Set *Key Encoding (Search/Type):* to UTF-8 for a text key, or choose the encoding of your key bytes.
3. Keep your message in *Input text*. Read the updated result with *Auto / Live* enabled, or click *Run*.

With message `abc`, key `key`, both encodings set to UTF-8, and *Hex (lower)* selected, the result is `085e4e83503f40b82fef38438bc4905a55dbaa8c8878097a899db0b57ce7da57a368251c34474f60b3ebacb39b2edaca4b290456411c76ec7ab61944cfe2288e`.

> This form sends the message and HMAC key to the calculation API. Use test keys rather than production secrets. Clear also empties the key field; review the HMAC switch and encoding settings before your next calculation.

### Use the exact SHA-3 variant

SHA3-512 produces **64 bytes**, normally displayed as **128 hexadecimal characters**. Selecting Base64 represents the same bytes differently. Output formatting does not switch the calculation to a different hash algorithm.

A SHA3-512 calculator is useful for checking test fixtures or an implementation that expects this precise SHA-3 variant. Use identical bytes on both sides: UTF-8 `abc`, Hex `616263`, and Base64 `YWJj` all describe the same three-byte message when the matching input encoding is selected.

SHA3-512 belongs to the SHA-3 family standardized in FIPS 202. It differs from SHA-512 in the SHA-2 family and from the original Keccak-512 variant. Choosing a similarly named algorithm can produce a perfectly valid but incompatible digest.

## Frequently asked questions

### What does a SHA3-512 hash look like?
The result contains 512 bits, or 64 bytes. Hex output uses 128 characters. Hex (lower), Hex (UPPER), and Base64 represent the same digest bytes in different ways.

### Is SHA3-512 the same as SHA-512?
No. SHA3-512 belongs to the SHA-3 family and uses a different construction from SHA-512 in the SHA-2 family. Both return 512-bit digests, but they calculate different values for the same input.

### Does SHA3-512 match Keccak-512?
No. Standardized SHA3-512 uses different domain separation from the original Keccak-512 variant. The shared underlying permutation does not make their digests interchangeable. Match the exact algorithm required by the system you are testing.

### Why is my SHA3-512 checksum different?
Check spaces, line endings, capitalization, and the selected input encoding. Confirm that the reference uses SHA3-512 rather than SHA-512 or Keccak-512. Also check whether either calculation has HMAC enabled.

### How does HMAC-SHA3-512 differ from a plain digest?
HMAC adds a secret key to authenticate a message. Reproducing the result requires the same message bytes, key bytes, and hash algorithm. Selecting Hex or Base64 for the key changes how the entered key is decoded, not the message encoding.

### Does this SHA3-512 calculation stay in my browser?
The form sends the entered data to the calculation API, including the key when HMAC is enabled. Use non-sensitive test messages and test keys. Local processing and a data retention policy cannot be inferred from the interface.

## Related Tools

- [Argon2 KDF](https://million.tools/argon2-kdf/): Generate a salted Argon2id encoded hash from test input. The current Argon2 KDF form returns a password-hash string rather than raw key bytes.
- [Argon2 Hash Generator](https://million.tools/argon2/): Generate a salted Argon2 password hash from text or encoded bytes. Copy the complete encoded string for development fixtures and password-verification tests.
- [SHA-224 Hash Generator](https://million.tools/sha224/): Generate a SHA-224 digest from text or encoded bytes. Choose hex or Base64 output, or test HMAC-SHA224 with a key.
- [Keccak-256 Hash Generator](https://million.tools/keccak-256/): Generate Keccak-256 hashes from text with UTF-8, Hex, or Base64 input. View live results, use HMAC mode, and copy Hex or Base64 output.
- [CRC-16 Calculator](https://million.tools/crc16/): Calculate 16-bit CRC checksums from text with CRC-16/ARC as the default. Choose input encoding, view hex or Base64 results, and copy the checksum.

## About the Author

**Egor Volchenko** — *Developer & Author*

Hi! I’m a WordPress developer with over 10 years of experience. I love Tailwind CSS, clean code, and intuitive interfaces. I’m currently working on million.tools — a service with convenient online tools for everyday tasks. I’m building it from scratch with great attention to detail and user experience.

- **Links:** [x.com](https://x.com/egorleet) · [github.com](https://github.com/egorleet) · [t.me](https://t.me/egorleet) · [instagram.com](https://www.instagram.com/egorleet) · [facebook.com](https://www.facebook.com/egorleet/) · [egorleet.blog](https://egorleet.blog/) · [mastodon.social](https://mastodon.social/@egorleet) · [twitch.tv](https://www.twitch.tv/egorvolchenko) · [stackoverflow.com](https://stackoverflow.com/users/31679135/egor-volchenko) · [reddit.com](https://www.reddit.com/user/Vegetable_Window9185/) · [youtube.com](https://youtube.com/@egor-volchenko)