ForHosting KIT · Travel & geography

Geohash child cells

The geohash u4pruyd splits into 32 children, from u4pruyd0 to u4pruydz, each one character longer and together covering the whole parent cell. Paste a geohash to get every child in the same fixed order, ready for indexing or maps. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
Geohash
u4pruyd
You get
Precision
7
Child precision
8
Quantity
32

The geohash child cells tool takes one existing geohash and subdivides its rectangular area into the thirty-two cells at the next precision level. It returns every child by appending each character from the canonical geohash base32 alphabet, in stable alphabet order, so the result is ready for indexing, mapping, testing, or recursive traversal. Input is normalized to lowercase, while invalid characters and unsupported lengths produce a clear input error. The calculation is deterministic and runs without a network connection, random values, or time-dependent behavior.

How geohash subdivision works

A geohash represents a rectangular geographic cell through an interleaved sequence of longitude and latitude bits. Each character contributes five more bits, so adding one character divides the parent cell into thirty-two smaller rectangles. Those rectangles are exactly the immediate children of the parent: no coordinate decoding, rounding, or spatial search is required to name them.

This capability appends every character in the canonical geohash alphabet, <code>0123456789bcdefghjkmnpqrstuvwxyz</code>, to the normalized parent. If the parent is <code>u4pruyd</code>, the first children are <code>u4pruyd0</code>, <code>u4pruyd1</code>, and so on, and the final child is <code>u4pruydz</code>. Every returned string therefore has the same parent prefix and is exactly one character longer.

Together, the thirty-two results cover the entire parent cell without gaps or overlap at that precision. Their order is stable and meaningful for deterministic systems: it follows character value, not geographic reading order. Use this operation when you need the complete next level of a geohash hierarchy rather than neighboring cells that sit beside the parent at its current precision.

Leading and trailing whitespace is removed and uppercase letters are converted to lowercase before validation. A valid value contains between one and twelve characters from the geohash base32 alphabet. Missing values, non-string values, strings empty after trimming, and inputs longer than the published limit are rejected as well.

The result contains no optional null fields. Because the output order and normalization rules are fixed, clients can compare, cache, and snapshot results without compensating for environmental differences.

Using child cells in spatial systems

Child generation is useful whenever a spatial application stores or explores locations as a prefix tree. A map service can begin with a broad cell, request its children, and continue subdividing only the branches that contain enough data to justify more detail. A database maintenance job can expand one coarse bucket into finer keys before redistributing records.

Test suites can also use the ordered output to verify that an encoder, prefix index, or recursive traversal handles every legal suffix and never admits forbidden base32 characters. Remember that this operation names cells; it does not calculate their latitude and longitude bounds, inspect which children contain data, or return the eight adjacent neighbors. Use a geohash decoder when you need coordinates or bounding boxes, and use a neighbor finder when you need cells beside an existing cell at equal precision.

Since each level multiplies the number of leaves by thirty-two, control recursion in the calling application and avoid materializing unnecessarily large trees. Stable canonical ordering makes streaming, pagination, cache keys, and reproducible batch jobs easy to implement.

Build a geohash prefix tree

Expand selected spatial buckets one level at a time while keeping every generated key in canonical, reproducible order.

Refine map aggregation cells

Replace a coarse map region with its complete set of next-precision cells before calculating finer statistics.

How many child cells does one geohash have?

Exactly 32 immediate children, because one appended geohash character contributes five bits and therefore represents 32 possible values.

Are the children returned in geographic order?

No. They are returned in canonical geohash base32 character order, which is stable but is not a north-to-south or west-to-east scan.

Does subdivision change the covered area?

The 32 children collectively cover the same area as their parent. Each individual child covers one subdivision at the next precision.

Which characters are valid?

Valid characters are 0–9 and bcdefghjkmnpqrstuvwxyz. The letters a, i, l, and o are not part of the geohash alphabet.

How do I go more than one level deeper?

Feed any child back in and split it again, repeating until you reach the precision you need, within the 12-character limit. Each level multiplies the number of cells by 32, so expand only the branches you need.

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

POSThttps://api.kit.forhosting.com/geo/geohash-children

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

curl -X POST https://api.kit.forhosting.com/geo/geohash-children \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"geohash":"u4pruyd"}'
{
  "geohash": "u4pruyd"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "geo.geohash_children",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_precision12
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Input validation and response fields

Send a JSON object containing the required <code>geohash</code> string. The shorter aliases <code>hash</code> and <code>gh</code> are accepted for compatibility, although new integrations should use the canonical field name. That alphabet deliberately omits a, i, l, and o to reduce visual ambiguity, so any of those letters produces an <code>invalid_input</code> response. A successful result includes <code>geohash</code>, the normalized parent; <code>precision</code>, its character length; <code>child_precision</code>, which is one greater; <code>children</code>, the ordered array of thirty-two child strings; and <code>count</code>, always thirty-two. A successful API request costs $0.002, while the browser tool can perform the same pure calculation locally.

Using child cells in spatial systems

Recursive subdivision is straightforward: feed any returned child back into this capability until the desired precision is reached, while respecting the input limit on every call.

Test geohash libraries

Generate the full legal suffix set for fixtures that verify prefix traversal, validation, and child-count invariants.

What does an API request cost?

Each successful API request costs $0.002. The browser version runs the same deterministic calculation locally for free.

Read the full KIT documentation →