# Xxh3 64 compute

`xxh3-64-compute` · version 1.0.0 · Hashing & signatures · free, no key needed

Compute the bit-exact XXH3 64-bit hash with a uint64 seed or public 192-byte custom secret.

**Use when you need to: compute XXH3 64-bit hash · hash bytes with XXH3 seed · hash data with an XXH3 custom secret.**

## Decide before calling

Read the [versioned contract](/v1/tools/xxh3-64-compute/versions/1.0.0) and the supported scope below. Reuse `xxh3-64-compute@1.0.0` when your input, required output and limits match it. Choose another approach for an unsupported operation.

## Explain the choice

"I can use `xxh3-64-compute@1.0.0` for compute XXH3 64-bit hash. I will check its documented scope and the result against the task's requirements. The service is free; token and money savings for this task are unmeasured."

## Supported

- compute XXH3 64-bit hash
- hash bytes with XXH3 seed
- hash data with an XXH3 custom secret
- reproduce an XXH3-64 cache key
- calculate an XXH3 checksum
- match a version-pinned XXH3 digest

## Not supported

- cryptographic hashing or authentication
- streaming state or secret generation

## Behavior

- Implements every XXH3 length path using xxHash v0.8.3 scalar semantics; seed and secret_hex are mutually exclusive.
- hex is the fixed-width big-endian display of the unsigned result; text decoding occurs before hashing.
- Disclaimer: format transform only; provides no confidentiality, integrity, or authenticity.

## Input

- `text` (string, required): max length 262144
- `input_encoding` (one of "utf8", "hex", "base64", "base64url", optional): default `"utf8"`
- `seed` (string, optional): pattern `^(0|[1-9][0-9]{0,20})$`; default `"0"`
- `secret_hex` (string, optional): pattern `^[0-9a-f]{384}$`

## Output

- `algorithm` (one of "xxh3-64", required)
- `hex` (string, required): pattern `^[0-9a-f]{16}$`
- `decimal` (string, required): pattern `^(0|[1-9][0-9]*)$`
- `standard` (string, required)
- `reference` (string, required)

## Limits

- max input bytes: 65536
- secret bytes: 192

## Example

Request input:

```json
{
  "text": ""
}
```

Response:

```json
{
  "result": {
    "algorithm": "xxh3-64",
    "hex": "2d06800538d394c2",
    "decimal": "3244421341483603138",
    "standard": "xxHash specification and upstream xxHash v0.8.3 sanity vectors",
    "reference": "Cyan4973/xxHash v0.8.3"
  }
}
```

## How to call it

### MCP

Connect `https://computefirst.net/mcp` ([setup](/docs#connect)), then call `execute` with:

```json
{
  "id": "xxh3-64-compute",
  "version": "1.0.0",
  "input": {
    "text": ""
  }
}
```

### HTTP (no key)

```sh
curl -X POST https://computefirst.net/v1/tools/xxh3-64-compute/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"text":""}'
```

The machine-readable contract is at [/v1/tools/xxh3-64-compute/versions/1.0.0](/v1/tools/xxh3-64-compute/versions/1.0.0).

### CLI

```sh
node cli.mjs run xxh3-64-compute 1.0.0 --input input.json --base-url https://computefirst.net
```

Get the client at [/clients/cli/](/clients/cli/).

## Related tools

- [Xxh3 128 compute](/tools/xxh3-128-compute): Compute the bit-exact XXH3 128-bit hash with a uint64 seed or public 192-byte custom secret.
- [Crc catalog compute](/tools/crc-catalog-compute): Compute a pinned RevEng CRC of hex bytes, including crossed-endian CRC-12/UMTS.
- [Crc catalog check](/tools/crc-catalog-check): Compare a claimed CRC with one pinned RevEng model, including CRC-12/UMTS.
- [Crc parametric compute](/tools/crc-parametric-compute): Compute a CRC using a named catalogue preset (CRC-8, CRC-16/ARC, CRC-32/ISO-HDLC, ...) or an explicit Rocksoft model.
- [Hash noncrypto compute](/tools/hash-noncrypto-compute): Compute FNV-1/1a, MurmurHash3 or xxHash over encoded input bytes, with an optional seed for algorithms that take one.
- [Xxh3 vector suite verify](/tools/xxh3-vector-suite-verify): Verify a bounded public suite of expected XXH3-64 and XXH3-128 known-answer vectors.