How to Find What's Within Walking Distance of a Place

You have a hotel, office, store, or listing and want to show what a person can reach on foot from it: cafés, restaurants, supermarkets, sights. A circle around the place counts things that are close in a straight line but hard to reach on foot. A walking isochrone—the area reachable within a time limit along real walking paths—gives a better answer.

This guide combines two APIs:

• The Isoline API calculates the area reachable on foot within 10 minutes and returns it with a reusable geometry ID.
• The Places API finds places of the requested categories inside that area with filter=geometry:<id>.

If your application already uses the Place Details API, it can return the same walking area together with the place record. The last API-request step shows how to search inside that polygon.

Task flow: place coordinates + 10 minutes on foot → walking area → places inside the area → list or map.

The example uses the Fairmont Olympic Hotel in downtown Seattle. Within a 10-minute walk it finds 169 cafés, restaurants, supermarkets, and sights; a straight-line 800-metre circle around the same hotel contains 296.

Choose how to define "within walking distance"

Choose the area by the question your users ask. A radius answers "how far in a straight line"; a walking isochrone answers "how far can I walk in N minutes".

For the same downtown Seattle hotel, the difference is large:

Recommend the walking isochrone when the result is shown to people as "within a 10-minute walk". Use a circle when speed and simplicity matter more than accuracy, and say "within 800 m" rather than "a 10-minute walk".

The walking area answers which places are reachable. It does not give the walking time to each place. The Places API distance property is the straight-line distance from the bias point. When each result needs its own walking time, calculate it with the Route Matrix API as shown in Find the nearest location by travel time.

Request the walking area

Send the place coordinates to the Isoline API with mode=walk, type=time, and range in seconds. A 10-minute walk is range=600:

https://api.geoapify.com/v1/isoline?lat=47.6080625&lon=-122.3339285&type=time&mode=walk&range=600&apiKey=YOUR_API_KEY

The coordinates are those of the Fairmont Olympic Hotel, 411 University Street, Seattle, WA 98101, as returned by forward geocoding. Unlike the Places API filters, the Isoline API takes lat and lon as separate parameters.

Reduced response: The response below keeps the properties and the first two positions of the walking area.

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
        "lat": 47.6080625,
        "lon": -122.3339285,
        "mode": "walk",
        "type": "time",
        "range": 600,
        "id": "4e9e301f1e1c22d052d6a9694dc94f5f"
      },
      "geometry": {
        "type": "MultiPolygon",
        "coordinates": [
          [
            [
              [-122.330928, 47.613134],
              [-122.330998, 47.613133],
              "…"
            ]
          ]
        ]
      }
    }
  ]
}

Keep two values from the response:

• properties.id identifies the calculated area. The next step passes it to the Places API instead of sending the polygon.
• geometry is the walking area in [longitude, latitude] order. Draw it on the map so users see what "within a 10-minute walk" covers.

The walking area follows walkable streets and paths, so it is irregular and can consist of several polygons. In this example, its farthest point is about 720 metres from the hotel in a straight line.

The Isoline API can return HTTP 202 with an empty FeatureCollection when a calculation takes longer than usual. In that case, keep the returned id and request the result again with https://api.geoapify.com/v1/isoline?id=<id>&apiKey=YOUR_API_KEY after a short wait. Short walking ranges usually return 200 directly.

Find places inside the walking area

Pass the isoline id to the Places API as filter=geometry:<id>. List the categories you need, and add bias=proximity:lon,lat with the place coordinates so the nearest results come first:

https://api.geoapify.com/v2/places?categories=catering.cafe,catering.restaurant,commercial.supermarket,tourism.sights&filter=geometry:4e9e301f1e1c22d052d6a9694dc94f5f&bias=proximity:-122.3339285,47.6080625&limit=20&apiKey=YOUR_API_KEY

Reduced response: The first three of 20 results, with the fields needed for a list or a map.

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
        "name": "4th Avenue Espresso Bar",
        "formatted": "4th Avenue Espresso Bar, 1206 4th Avenue, Seattle, WA 98101, United States of America",
        "categories": ["catering", "catering.cafe", "catering.cafe.coffee"],
        "distance": 33,
        "lat": 47.6078793,
        "lon": -122.3342728,
        "place_id": "…"
      },
      "geometry": { "type": "Point", "coordinates": [-122.3342728, 47.6078793] }
    },
    {
      "type": "Feature",
      "properties": {
        "name": "The George",
        "formatted": "The George, 411 University Street, Seattle, WA 98161, United States of America",
        "categories": ["catering", "catering.restaurant"],
        "distance": 46,
        "lat": 47.6084603,
        "lon": -122.3337829,
        "place_id": "…"
      },
      "geometry": { "type": "Point", "coordinates": [-122.3337829, 47.6084603] }
    },
    {
      "type": "Feature",
      "properties": {
        "name": "Shuckers Oyster Bar",
        "formatted": "Shuckers Oyster Bar, 411 University Street, Seattle, WA 98161, United States of America",
        "categories": ["catering", "catering.restaurant", "catering.restaurant.seafood"],
        "distance": 47,
        "lat": 47.607669,
        "lon": -122.3341491,
        "place_id": "…"
      },
      "geometry": { "type": "Point", "coordinates": [-122.3341491, 47.607669] }
    }
  ]
}

With limit=500, the same request returns all 169 matches inside the walking area: 78 cafés, 83 restaurants, 2 supermarkets (PCC Corner Market and H Mart), and 6 sights. The farthest result is 655 metres from the hotel in a straight line. For more results than one page holds, use offset as described in How to Paginate Through Place Search Results.

To group results for display, read properties.categories: a place belongs to catering.cafe when that value is in its list. A place can carry several categories.

Check the filter. If the Places API does not recognise the geometry ID, it ignores the filter and returns matching places from outside the area—without an error. Use the id from the Isoline API response; currently, the id of a Place Details walk_10 feature is not accepted until the same area has been requested from the Isoline API. To catch this, compare each result's distance with the extent of the walking area, or check that results lie inside the polygon you draw. If the ID is not accepted, request the isoline again, or send the polygon itself as shown in the next step.

properties.distance is the straight-line distance from the bias point in metres, not the walking distance. Do not label it as walking time.

Use a walking area from Place Details

When your application looks up the place with the Place Details API, request the walking area in the same call with features=details|walk_10:

https://api.geoapify.com/v2/place-details?lat=47.6080625&lon=-122.3339285&features=details|walk_10&apiKey=YOUR_API_KEY

The response contains a details feature with the hotel record and a walk_10 feature with the walking area. Select them by properties.feature_type. The walk_10 geometry is the same 10-minute walking area as in the Isoline API step. Place Details offers walk_5, walk_10, walk_15, and walk_30.

To find places inside that area, send its geometry to the Places API in a POST request with a polygon filter. In the POST body, bias is an object, not a proximity:lon,lat string:

POST https://api.geoapify.com/v2/places?apiKey=YOUR_API_KEY
Content-Type: application/json

{
  "categories": [
    "catering.cafe",
    "catering.restaurant",
    "commercial.supermarket",
    "tourism.sights"
  ],
  "filter": {
    "type": "polygon",
    "geometry": {
      "type": "MultiPolygon",
      "coordinates": [
        [
          [
            [-122.330928, 47.613134],
            [-122.330998, 47.613133],
            "…"
          ]
        ]
      ]
    }
  },
  "bias": {
    "type": "proximity",
    "lon": -122.3339285,
    "lat": 47.6080625
  },
  "limit": 500
}

The geometry in this example is shortened. Send the complete walk_10 geometry unchanged: the 10-minute area has 129 positions, well within the limits of 10,000 positions and 102,400 bytes described in Find places in a custom polygon.

The response has the same format as the GET request and the same result: 169 places, all inside the walking area. The POST request does not depend on a stored geometry ID, so it is the safer choice when the polygon comes from Place Details or from your own storage.

The Place Details reference also lists category values such as walk_10.restaurant. Do not rely on them for this task: they currently return no features. Search places with the Places API as shown here.

"Within walking distance" feature with an AI coding agent

Copy this prompt into Codex, Claude Code, Cursor, or another coding agent to add a "within a 10-minute walk" list or map to your project.

Add a "what's within walking distance" feature to my project with the Geoapify Isoline API and Places API.

Before you start
- Ask which language and framework the project uses, where the requests run (backend, browser, or CLI), and whether the result is a list, a map layer, or both.
- Ask for the walking time (for example 5, 10, or 15 minutes) and the Geoapify place categories to search (for example catering.cafe, catering.restaurant, commercial.supermarket, tourism.sights).
- Ask how the origin is provided: coordinates, an address to geocode, or a Geoapify place ID.
- Ask me to configure a Geoapify API key before live requests. On a backend or CLI, read it from GEOAPIFY_API_KEY. In a browser, ask whether to use a restricted key or a backend proxy. Never hardcode, print, or log the key.

API flow
1. GET https://api.geoapify.com/v1/isoline with lat, lon, type=time, mode=walk, and range in seconds (10 minutes = 600). If the response is HTTP 202, wait and request /v1/isoline?id=<id> until the area is ready, with a bounded number of retries.
2. Keep properties.id and the MultiPolygon geometry ([longitude, latitude] order).
3. GET https://api.geoapify.com/v2/places with categories, filter=geometry:<id>, bias=proximity:lon,lat, limit, and offset for paging.

Requirements
- Use only the id returned by the Isoline API in the geometry filter. If the polygon comes from elsewhere (for example a Place Details walk_10 feature), POST it to /v2/places with "filter": { "type": "polygon", "geometry": <geometry> } and "bias": { "type": "proximity", "lon": ..., "lat": ... }.
- The Places API ignores an unknown geometry id without an error. Verify that returned places lie inside the walking polygon and fall back to the POST polygon request if they do not.
- Show properties.distance only as straight-line distance; never label it as walking time.
- Group results by properties.categories and draw the walking area on the map when there is one.
- Handle empty results, HTTP errors, timeouts, and limited 429 retries with backoff. Bound pagination.
- Add a short test with mocked responses and a usage example.

Review the generated code against the requests in this guide. Check the range unit (seconds), coordinate order, the source of the geometry ID, the inside-the-area check, the distance label, and API-key handling.