SeedCracker Documentation

Overview

SeedCracker is a functional seed-cracking tool for Minecraft Bedrock. The console defaults to the automatic mode (see below): list your structures - no seed range to set - and it sweeps the 32-bit space and finishes 64-bit worlds from your Trial Chambers / Trail Ruins anchors. The POST /seedcracker HTTP API documented on this page searches the seed space within the range you set (default: the full 32-bit space) in parallel (native library) and keeps the seeds whose generated structures line up with the coordinates you provide. The more structures you list - and the tighter the tolerance - the fewer candidate seeds come back. Because a full sweep is measured in minutes, you can bound the request with a time budget (max_seconds, up to 7200 s / 2 h); leave it out and the sweep runs to completion. Results are returned even when the search is stopped early.

Automatic mode

The console's default flow needs no seed range and no time budget: list 4 or more structures (type + block coordinates), add Trial Chambers / Trail Ruins anchors if you have them, and press Find seeds. Everything runs in your browser.

1. Sweep — the whole 32-bit seed space is swept with placement only (no biome gate), in slices of 2²⁶ seeds, and the best 2000 candidates are ranked by score.
2. 32-bit detection — every ranked candidate is validated with placement and biome under seed = lo32. Any hit means a 32-bit world: you get all of them, ranked.
3. Anchor lift — no hit and no anchors? The world is 64-bit and the search stops with "Your world likely uses a 64-bit seed — add 2-3 Trial Chambers". With anchors, the best-ranked candidate is lifted 32→48 bits through them.
4. High-bit lift — the remaining 15 bits are resolved with the biome gate, spread across your CPU cores.

Results come back ranked, with your coordinates next to where each seed actually generates the structure, a copy button, and a link that opens the seed in SeedFinder. Seeds above 2⁵³ are displayed from seed_str, so they are always verbatim. Time limit, Max results and Max score (under Advanced) apply to both searches; filling Start/End selects the manual windowed search.

Availability

The SeedCracker console runs in your browser: the seed search engine is compiled to WebAssembly and executed locally with your CPU cores — no server involved, works on the hosted deployment too.

The POST /seedcracker HTTP API still runs on the local API only (http://127.0.0.1:7890, started with server\start.bat or server/start.sh).

[
  {
    "status": "unavailable",
    "message": "The SeedCracker HTTP API is not available on Vercel (too expensive to host). The browser console runs the same search locally via WebAssembly - use it at /seedcracker.",
    "download": "https://github.com/zebedelu/SeedFinder/releases",
    "console": "/seedcracker",
    "docs": "/seedcracker/documentation"
  }
]

The HTTP route is too expensive to host for free; the console above runs the same engine in your browser.

Base URL

http://127.0.0.1:7890

Endpoints POST /seedcracker and GET /seedcracker

Both verbs accept the same parameters. POST uses a JSON body (recommended); GET uses the query string with structures serialized as semicolon-separated type,x,z groups.

POST /seedcracker - 400 response:

[
  {
    "status": "error",
    "message": "at least 4 structures are required"
  }
]

503 response (native library missing / not loaded):

[
  {
    "status": "error",
    "message": "SeedCracker native library (.dll/.so) not loaded on this server."
  }
]

Parameters

Request format

The canonical body is a list: the first item is the options object (tolerance and friends live at the root of the list), followed by the structure objects.

[
  {"tolerance": 0, "max_seconds": 120},
  {"type": 5, "x": -280, "z": 152},
  {"type": 5, "x": -280, "z": -360},
  {"type": 8, "x": 696, "z": 360},
  {"type": 8, "x": 712, "z": 760}
]

An object body with a structures key is accepted too:

{
  "tolerance": 0,
  "max_seconds": 120,
  "structures": [
    {"type": 5, "x": -280, "z": 152},
    {"type": 5, "x": -280, "z": -360},
    {"type": 8, "x": 696, "z": 360},
    {"type": 8, "x": 712, "z": 760}
  ]
}

GET form:

http://127.0.0.1:7890/seedcracker?tolerance=0&max_seconds=120&structures=5,-280,152;5,-280,-360;8,696,360;8,712,760

Response format

The response is always a list. Item 0 is the header (status: ok, partial when the time budget ran out, error or unavailable), followed by the matched seeds with a score (sum of squared chunk deviations across structures, in chunks - lower is better, 0 = perfect) and the matched structure chunk coordinates (each chunk is 16 by 16 blocks), one per structure in the same order you submitted them.

[
  {
    "status": "ok",
    "message": "crack completed",
    "structures": 4,
    "tolerance": 0,
    "units": "blocks",
    "checked": 16000000,
    "elapsed_ms": 2800,
    "timed_out": false
  },
  {
    "seed": 8675309,
    "score": 0,
    "matches": [[-18, 9], [-18, -23], [43, 22], [44, 47]]
  }
]

Structure IDs

SeedCracker accepts the same IDs as SeedFinder, except Mineshaft (15), which uses a per-chunk RNG and cannot be searched by region.

Live examples (local)

Run the server with server\start.bat, then run the requests below. Example A finds the exact seed 8675309 from 2 villages and 2 monuments; example B uses a 2-chunk tolerance on seed 31415.

Example A - exact match (tolerance 0)

curl -X POST http://127.0.0.1:7890/seedcracker \
  -H "Content-Type: application/json" \
  -d '[{"tolerance":0,"max_seconds":120},{"type":5,"x":-280,"z":152},{"type":5,"x":-280,"z":-360},{"type":8,"x":696,"z":360},{"type":8,"x":712,"z":760}]'

Expected response:

[
  {"status":"partial","message":"search stopped by time budget - results are partial","structures":4,"tolerance":0,"units":"blocks","checked":660275200,"elapsed_ms":120000,"timed_out":true},
  {"seed":8675309,"score":0,"matches":[[-18,9],[-18,-23],[43,22],[44,47]]}
]

Example B - tolerance 2 (4 villages from seed 31415)

curl -X POST http://127.0.0.1:7890/seedcracker \
  -H "Content-Type: application/json" \
  -d '[{"tolerance":2,"max_seconds":30,"max":50},{"type":5,"x":-1448,"z":-264},{"type":5,"x":-360,"z":-840},{"type":5,"x":168,"z":1176},{"type":5,"x":136,"z":-1352}]'

Expected response (first item + the top seed):

[
  {"status":"partial","message":"search stopped by time budget - results are partial","structures":4,"tolerance":2,"units":"blocks","checked":615841792,"elapsed_ms":120000,"timed_out":true},
  {"seed":31415,"score":0,"matches":[[-91,-17],[-23,-53],[10,73],[8,-85]]}
]

A looser tolerance admits many seeds (hundreds with a 2-chunk radius). The best one by score - seed 31415 - is on top; the matches order follows the order of the structures you submitted.

Client examples

Pick a language below to see how to call /seedcracker with requests (Python) or network.post (Lua, e.g. inside Flarial Client).

import requests

BASE = "http://127.0.0.1:7890"

# Standard list form: options object first, then the structures.
payload = [
    {"tolerance": 0, "max_seconds": 120, "max": 50},
    {"type": 5, "x": -280, "z": 152},
    {"type": 5, "x": -280, "z": -360},
    {"type": 8, "x": 696, "z": 360},
    {"type": 8, "x": 712, "z": 760},
]

r = requests.post(f"{BASE}/seedcracker", json=payload, timeout=200)
r.raise_for_status()
data = r.json()  # list: [header, seed, seed, ...]

print(data[0])  # {"status": "ok", "checked": ..., ...}
for result in data[1:]:
    print(f"seed={result['seed']} score={result['score']} matches={result['matches']}")

-- Drop-in for Flarial Client modules. `network` is a Flarial global.
local BASE = "http://127.0.0.1:7890"

local payload = {
    { tolerance = 0, max_seconds = 120, max = 50 },
    { type = 5, x = -280, z = 152 },
    { type = 5, x = -280, z = -360 },
    { type = 8, x = 696,  z = 360 },
    { type = 8, x = 712,  z = 760 },
}

local resp = network.post(BASE .. "/seedcracker", jsonencode(payload))
if not resp or resp.code ~= 200 then
    print("[seedcracker] HTTP error: " .. tostring(resp and resp.code))
    return nil
end
print(resp.body)  -- JSON list; decode with your JSON lib if needed

Performance & notes

• In the local API the search sweeps with as many threads as CPU cores (capped at 64); the browser console parallelizes across Web Workers instead.
• Structures with the smallest generation cell are tested first, so most seeds are rejected after one or two checks.
• tolerance is a radius in chunks (Euclidean), default 6. With tolerance 0 a fixed set of coordinates usually maps to a single seed.
• The result cap keeps the max best seeds by score; a looser tolerance makes many seeds pass - narrow it for a sharper answer.
• max_score (default 10) hides seeds whose score is above it, so only the best-fitting seeds are shown; raise it to see weaker matches.
• Mineshaft (15) is rejected; tolerance beyond 8 is rejected; max_seconds beyond 7200 is capped. Omit max_seconds to run the sweep to completion.

Attribution

Using SeedCracker, or the seeds it finds, in your own project, bot or website? No sign-up and no permission needed - just credit the service with a powered by SeedFinder line linking to the home page, wherever you show the results. The same applies to the links shared from the console: keep the preview card pointing here.

<a href="https://www.mineseedfinder.com/">powered by SeedFinder</a>