ForHosting KIT · Travel & geography

Map tile to lat/lon

Find the north-west corner of any web map tile from its column, row and zoom: tile 0/0/0 starts at 85.0511287798° north and 180° west. Handy when you read tile addresses in logs or check homework. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Tile column index: 0
Tile row index: 0
Zoom level: 0

You get

Zoom: 0
Latitude: 85.0511287798
Longitude: -180
Latitude: 85.0511287798

This map tile to lat lon calculator converts a slippy-map tile address — column X, row Y, and zoom Z — into the geographic latitude and longitude of that tile’s north-west corner under Web Mercator projection. The same XYZ numbering powers OpenStreetMap, Leaflet, Mapbox, and countless raster caches: at zoom zero a single tile covers the world; each zoom step doubles the grid on each axis so four children cover what one parent covered. The engine uses the classic closed-form formulas n equals two to the z, longitude equals x over n times three hundred sixty minus one hundred eighty, and latitude equals arctangent of sinh of pi times one minus two y over n, converted to degrees. Known checks include x zero y zero z zero near eighty-five point zero five degrees north and one hundred eighty west, and x one y zero z one at the same latitude with longitude zero. The path is pure finite arithmetic with no network tile fetches, no sampling, and no date-dependent shortcuts.

What map tiles are and what you get back

A slippy map tile is one square cell in a fixed Web Mercator grid addressed by integers x, y, and z. Zoom z sets the resolution: there are two to the z columns and the same number of rows, so the world is covered by four to the z tiles. Column x increases eastward from the antimeridian; row y increases southward from the northern edge of the mercator square, so y equals zero is always the northernmost band.

This calculator returns the geographic coordinates of the north-west corner of the requested tile — the point with the largest latitude and smallest longitude of that cell — not the center and not the south-east corner.

What you can do with it

Debug tile URLs and CDN logs

Paste x, y, and zoom from a raster path or 404 log and see the NW corner lat/lon for quick geographic context.

GIS homework and teaching demos

Check textbook answers for slippy-map NW corners without re-implementing sinh and atan on a calculator by hand.

FAQ

What does the map tile to lat/lon calculator cost?

It is free in your browser on this page.

Which corner of the tile is returned?

The north-west corner only — maximum latitude and minimum longitude of the tile cell under the XYZ slippy scheme.

What happens if x or y is outside the zoom range?

For zoom z, both x and y must be integers in [0, 2^z − 1].

Why are results rounded to a precision?

Default precision is 10 decimal places; you can set precision from 0 to 15.

Why does the world tile stop near 85.05° instead of reaching the pole?

The Web Mercator map is drawn as a square that never reaches the poles. At zoom 0 the north-west corner of the only tile is at 85.0511287798° north and 180° west.

Related tools

For developers — API access

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.

API endpoint

POSThttps://api.kit.forhosting.com/geo/tile-to-latlon

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.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/geo/tile-to-latlon \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"x":0,"y":0,"z":0}'

const res = await fetch("https://api.kit.forhosting.com/geo/tile-to-latlon", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "x": 0,
    "y": 0,
    "z": 0
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/geo/tile-to-latlon",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "x": 0,
    "y": 0,
    "z": 0
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/geo/tile-to-latlon", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"x":0,"y":0,"z":0}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"x":0,"y":0,"z":0}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geo/tile-to-latlon", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "x": 0,
  "y": 0,
  "z": 0
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "geo.tile_to_latlon",
  "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.

Pricing

Per request$0.002

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

Limits

max_zoom 22

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

What slippy tiles are and what the response contains

The response echoes the validated integers x, y, and z, a zoom alias, latitude and longitude rounded to the requested precision, short lat and lon aliases, the grid size n equals two to the z, a corner tag set to north_west, the method tag slippy_web_mercator, the precision used, and a compact formula string for documentation. There is no reverse geocoding path, no network call to a tile CDN, and no random jitter: the engine either projects the NW corner inside the supported zoom range or rejects the input with invalid_input. Rejected cases include missing x, y, or z, non-integer values, zoom outside zero through twenty-two, and any tile index that is negative or greater than or equal to two to the z for that zoom.

How x, y, and z are read and how lat/lon stay reproducible

Zoom must lie in zero through twenty-two inclusive, matching common web-map practice and keeping two to the z inside a safe integer grid. The preferred fields are x for the tile column, y for the tile row, and z for the zoom level, but aliases tile_x, col, and column for x, tile_y and row for y, and zoom, zoom_level, and level for z are accepted so query strings, spreadsheets, and typed forms can reuse the same contract. Values may arrive as JSON numbers or as decimal integer strings; floats, hex prefixes, and empty strings are rejected with a clear message so a bad cell does not become a wrong meridian. After z is known, both x and y must satisfy zero less than or equal to index less than two to the z; an out-of-range pair fails with invalid_input and an explicit message that the tile indices exceed the range allowed for that zoom. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for latitude and longitude, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing Web Mercator yourself.

Where tile-to-coordinate conversion fits in maps, GIS, and software

GIS students use the same conversion when a course introduces Web Mercator after plate carrée and asks for the latitude of the top edge of a given tile. Contest and interview practice often needs a fast offline source of NW corners so candidates can verify hand calculations under time pressure. Product tools use the projection when a support engineer pastes x, y, and z from a CDN log and needs geographic context in one step. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with geohash decode or other geo endpoints when you are building a small lab of free, deterministic mapping helpers, and keep this tool focused on the single question: given a slippy tile, where is its north-west corner on Earth.

Integration use cases

Deterministic map test fixtures

Generate reproducible latitude and longitude for unit tests of Web Mercator layout, zoom math, and tile-bound labels.

Technical questions

Is this the same grid as OpenStreetMap and Leaflet?

Yes. It uses the standard Web Mercator XYZ numbering (y=0 at the north, x=0 at longitude −180).

Read the full KIT documentation →

Run — free