Call the free SHA512 hash API endpoint
curl -X POST https://aisenseapi.com/services/v1/sha512_hash \
-H "Content-Type: application/json" \
-d '{"data":"Hello world"}'{"sha512_hash":"b7f783baed8297f0db917462184ff4f08e69c2d5e5f79a942600f9725f58ce1f29c18139bf80b06c0fff2bdd34738452ecf40c488c22a7e3d80cdf6f9c1c0d47"}Count the characters in that value and you get 128. That is 64 bytes, or 512 bits, which is where the algorithm gets its name. The digest itself is a constant. Any correct SHA-512 implementation, in any language, on any machine, returns those same 128 characters for the eleven bytes of Hello world.
Raw bodies work too. Send the bytes as text/plain and you skip the business of escaping quotes and newlines into JSON.
curl -X POST https://aisenseapi.com/services/v1/sha512_hash \
-H "Content-Type: text/plain" \
--data-binary "Hello world"{"sha512_hash":"b7f783baed8297f0db917462184ff4f08e69c2d5e5f79a942600f9725f58ce1f29c18139bf80b06c0fff2bdd34738452ecf40c488c22a7e3d80cdf6f9c1c0d47"}Both calls hash the same eleven bytes, so both return the same line. Trailing newlines are the classic trap. A shell echo quietly appends one, and that single extra byte rewrites every character of the digest.
Response fields
| Field | Type | Description |
|---|---|---|
| sha512_hash | string | Exactly 128 characters of lowercase hex. The length never varies. One byte of input and one gigabyte of input both produce 128 characters, and empty input still returns a valid digest. |
Input is treated as bytes. Text is hashed as UTF-8, so accented letters and emoji contribute their encoded bytes rather than any abstract code point. A local library that encodes the same string as UTF-16 will disagree with this service. Check encoding second, right after you have ruled out stray whitespace.
The speed surprise most people miss
Here is the detail that catches almost everyone out. On 64-bit hardware SHA-512 is frequently faster per byte than SHA-256.
Word size explains it. SHA-512 does its arithmetic on 64-bit words and chews through 128-byte blocks. SHA-256 works on 32-bit words and 64-byte blocks. A 64-bit CPU handles a 64-bit word in one register operation, so SHA-512 moves twice the data per round for the same effort. The bigger number in the name is not the slower algorithm.
Two conditions flip that result. On 32-bit microcontrollers the 64-bit arithmetic has to be emulated in software, which makes SHA-512 the expensive option. And on modern x86 and ARM chips with SHA-256 instructions built into the silicon, hardware acceleration puts SHA-256 comfortably back in front.
Measure on the hardware you will actually deploy to. The free SHA512 hash API endpoint settles questions of correctness for you, but throughput is a property of your own machine rather than of this service.
What the longer digest actually buys
A 512-bit fingerprint occupies twice the width of a SHA-256 one in every log line, manifest column and database field. Storage is cheap. Readability is not, so the extra width should earn its keep.
Collision headroom is rarely the honest argument. SHA-256 already offers far more than any real system will exhaust. Two reasons do hold up. Long-lived archives benefit from cheap insurance against assumptions that may not survive the decade. And some specifications, signature profiles and procurement rules name SHA-512 outright, which settles the matter before you get a vote.
Watch one trap. Truncating this output to 64 characters does not give you SHA-512/256. That variant is a separate algorithm with different initial hash values, and its digests will never match a cut-down SHA-512.
For everything else, SHA-256 remains the interoperability default that package registries, release checksums and most tooling expect. When you want the shorter digest, call the SHA-256 hash API endpoint instead.
Compare a digest without leaking timing
Comparing two digests in your own code is easy to get subtly wrong. POST /hash_verify takes data and an expected hash and reports the result for you.
curl -X POST https://aisenseapi.com/services/v1/hash_verify \
-H "Content-Type: application/json" \
-d '{"data":"Hello world","hash":"b7f783baed8297f0db917462184ff4f08e69c2d5e5f79a942600f9725f58ce1f29c18139bf80b06c0fff2bdd34738452ecf40c488c22a7e3d80cdf6f9c1c0d47"}'{"match":true,"algorithm":"sha512","computed":"b7f783baed8297f0db917462184ff4f08e69c2d5e5f79a942600f9725f58ce1f29c18139bf80b06c0fff2bdd34738452ecf40c488c22a7e3d80cdf6f9c1c0d47"}The algorithm is inferred from the length you supply, so a 128-character hex string is read as SHA-512. The comparison runs in constant time. A wrong first character costs exactly as long as a wrong last one, which matters because ordinary string equality exits at the first mismatch and leaks, through timing, how much of a guess was correct. Note that computed comes back on a mismatch as well, so you see what your input really hashes to instead of a bare false. The hash verify API endpoint page covers the full behaviour.
Do not store passwords this way
Never keep passwords as SHA-512 digests. Speed is the design goal of this algorithm, and speed is precisely the wrong property for password storage. Commodity hardware grinds through enormous numbers of these per second, so a stolen table falls to a dictionary attack quickly. Reach for a deliberately slow key derivation function instead: bcrypt, scrypt or Argon2, each of which salts per password and exposes a tunable work factor.
The longer digest changes nothing here. Length defends against collisions, and password cracking is guessing rather than collision hunting. Adding your own salt to a fast hash defeats precomputed tables but leaves raw guessing speed untouched, and guessing speed decides the outcome. The same warning covers the SHA-1 hash API endpoint and the MD5 hash API endpoint, which are faster still.
Common uses
Callers reach for the free SHA512 hash API endpoint in a handful of recurring situations.
Archival manifests
Record a digest beside every file in a long-lived archive. A re-hash years later tells you which objects survived intact, with no second copy needed for comparison.
Standard-mandated digests
Some specifications and signature profiles name SHA-512 explicitly. When that is the requirement, this endpoint produces the exact value a reviewer will check against.
Large file checksums
On 64-bit servers without SHA-256 instructions, SHA-512 often finishes a multi-gigabyte file sooner. Use it to fingerprint release artifacts, backups and disk images.
Cross-implementation debugging
When your library and someone else's disagree, hash the same input here. A neutral third implementation turns an argument about code into a question about encoding.
Content addressing
Key a cache or object store by digest so identical bytes always land on the same key. Duplicate uploads then collapse into one stored object.
Privacy and limits
The input travels in the POST body rather than the URL, so it never lands in a request path or a proxy access log. A hash is still not encryption, and your plaintext reaches this service before it is hashed. SHA-512 ships in every standard library, so keep genuinely confidential material inside your own process and use this service for testing, tooling and content you are happy to send.
The free SHA512 hash API endpoint shares the service-wide ceiling of 5000 requests per IP per 24 hours. No key, no account and no signup step stand in the way. Every route sits under the base URL https://aisenseapi.com/services/v1, and the whole catalogue is listed on Free public REST APIs.