Find restaurants that deliver to a UK postcode (Just Eat).

Lists Just Eat restaurants (and shops) that deliver to, or offer collection near, a UK postcode: rating, delivery time, delivery fee, minimum order, free-delivery threshold, cuisines, deals and menu link. Filters by cuisine, name and open-now. Paid promoted placements are removed by default, so the order is Just Eat's organic ranking.

No reports yetRead-only, no login

Site: Just Eat, United Kingdom
Version: v2 of 2
Runs, last 7 days: No reports yet
sha256: a8908770153f…

Run it with your agent

after installing Wield

Ask in plain words. Your agent finds this recipe and calls it:

“Find restaurants that deliver to a UK postcode (Just Eat).”

Read-only: it changes nothing on the site. No login needed.

{
  "tool": "run",
  "arguments": {
    "recipe_id": "just-eat.co.uk/search-restaurants",
    "params": {
      "cuisine": "pizza",
      "limit": 10,
      "open_now": false,
      "postcode": "EC4M 7RF"
    }
  }
}

Requests

sent from your browser, in order

1GETuk.api.just-eat.io/discovery/uk/restaurants/enriched/bypostcode/{{f.pc}}?ratingsOutOfFive&serviceType&verticalJust Eat UK's discovery API on uk.api.just-eat.io (Just Eat's own API; just-eat.co.uk calls it cross-origin), by postcode: all restaurants for the postcode in one response, fees and paid placements in top-level maps. The one-item foreach writes the postcode without spaces.no cookiesrepeats, max 1

Parameters

from your agent

cuisinestringCuisine filter, matched against Just Eat's cuisine names, e.g. 'pizza', 'indian', 'chinese', 'sushi', 'vegan'

include_sponsoredbooleanKeep paid sponsored placements (marked sponsored: true) = false

limitenumMaximum restaurants returned (5, 10, 25 or 50) 5 | 10 | 25 | 50 = 25

namestringOnly restaurants whose name contains this text

open_nowbooleanOnly restaurants open now for the chosen service = true

postcodestringrequiredFull UK postcode, e.g. 'EC4M 7RF', 'M1 1AE'

serviceenumdelivery or collection (pickup) "delivery" | "collection" = "delivery"

sortenumdefault = Just Eat's organic ranking; rating = best rated first, weighted by number of reviews; distance = closest first "default" | "rating" | "distance" = "default"

Returns

to your agent

areastring

postal_codestring

postcodestring

restaurantsobject[]address, cuisines, deals, delivery_fee_gbp, distance_m, eta_min_from, eta_min_to, free_delivery_from_gbp, id, min_order_gbp, name, new, open_now, rating, rating_count, sponsored, url

totalintegerMatching restaurants before limit

Where it can send

uk.api.just-eat.io

Anything else is blocked by the extension.

Reads from your session

Nothing. Your browser attaches the site's cookies by itself.

Used only in requests to the addresses on the left. Never sent to wield.run or your agent.

Checks

a run passes when

length(output.restaurants) > `0`
output.total >= length(output.restaurants)
output.area == 'London'
length(output.restaurants[?sponsored]) == `0`
length(output.restaurants[?open_now == `true` || open_now == `false`]) == length(output.restaurants)
starts_with(output.restaurants[0].url, 'https://www.just-eat.co.uk/restaurants-')
output.restaurants[0].min_order_gbp != `null`

Raw recipe

Served as canonical JSON from /api/v1/recipes/just-eat.co.uk/search-restaurants, so its sha256 matches the ETag and the index.

Check it yourself

curl -s https://wield.run/api/v1/recipes/just-eat.co.uk/search-restaurants | shasum -a 256
# a8908770153fdc8e2e23dc7670684a87b5597327141069539cb307fb8a28a82a

just-eat.co.uk/search-restaurants.json, v2

{
  "description": "Lists Just Eat restaurants (and shops) that deliver to, or offer collection near, a UK postcode: rating, delivery time, delivery fee, minimum order, free-delivery threshold, cuisines, deals and menu link. Filters by cuisine, name and open-now. Paid promoted placements are removed by default, so the order is Just Eat's organic ranking.",
  "effect": "read",
  "id": "just-eat.co.uk/search-restaurants",
  "keywords": [
    "just eat",
    "takeaway",
    "food delivery",
    "order food",
    "restaurants near me",
    "delivery",
    "collection",
    "pizza",
    "curry",
    "chinese",
    "indian",
    "burger",
    "sushi",
    "uk",
    "london"
  ],
  "output": {
    "schema": {
      "properties": {
        "area": {
          "type": [
            "string",
            "null"
          ]
        },
        "postal_code": {
          "type": [
            "string",
            "null"
          ]
        },
        "postcode": {
          "type": [
            "string",
            "null"
          ]
        },
        "restaurants": {
          "items": {
            "properties": {
              "address": {
                "type": "string"
              },
              "cuisines": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "deals": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "delivery_fee_gbp": {
                "description": "Fee at the minimum order value",
                "type": [
                  "number",
                  "null"
                ]
              },
              "distance_m": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "eta_min_from": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "eta_min_to": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "free_delivery_from_gbp": {
                "description": "Order value from which delivery is free, if any",
                "type": [
                  "number",
                  "null"
                ]
              },
              "id": {
                "type": "string"
              },
              "min_order_gbp": {
                "type": [
                  "number",
                  "null"
                ]
              },
              "name": {
                "type": "string"
              },
              "new": {
                "type": "boolean"
              },
              "open_now": {
                "type": "boolean"
              },
              "rating": {
                "description": "0-5 stars; 0 when unrated",
                "type": [
                  "number",
                  "null"
                ]
              },
              "rating_count": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "sponsored": {
                "type": "boolean"
              },
              "url": {
                "format": "uri",
                "type": "string"
              }
            },
            "type": "object"
          },
          "type": "array"
        },
        "total": {
          "description": "Matching restaurants before limit",
          "type": "integer"
        }
      },
      "required": [
        "postcode",
        "area",
        "total",
        "restaurants"
      ],
      "type": "object"
    },
    "value": "let $s = steps.restaurants[0], $c = lower(params.cuisine || ''), $n = lower(params.name || ''), $open = params.open_now, $svc = params.service, $inc = params.include_sponsored in let $m = $s.all[?(!$open || (($svc == 'delivery' && open_delivery) || ($svc == 'collection' && open_collection))) && !offline && ($c == '' || length(cuisines[?contains(lower(@), $c)]) > `0` || length(cuisine_keys[?contains(@, $c)]) > `0`) && ($n == '' || contains(lower(name), $n)) && ($inc || !contains($s.sponsored_ids, id))] in let $o = (params.sort == 'rating' && reverse(sort_by($m, &(((rating || `0`) * (rating_count || `0`) + `80`) / ((rating_count || `0`) + `20`))))) || (params.sort == 'distance' && sort_by($m, &distance_m || `999999`)) || $m in {postcode: $s.postal_code, area: $s.area, total: length($m), restaurants: ((params.limit == `5` && $o[:5]) || (params.limit == `10` && $o[:10]) || (params.limit == `50` && $o[:50]) || $o[:25])[].let $f = (let $id2 = id in $s.fees[?restaurantId == $id2] | [0]) in {id: id, name: name, url: url, cuisines: cuisines, rating: rating, rating_count: rating_count, open_now: $svc == 'delivery' && open_delivery || ($svc == 'collection' && open_collection), eta_min_from: eta_min_from, eta_min_to: eta_min_to, distance_m: distance_m, delivery_fee_gbp: $f.bands[0].fee != `null` && $f.bands[0].fee / `100` || `null`, min_order_gbp: $f.minimumOrderValue != `null` && $f.minimumOrderValue / `100` || `null`, free_delivery_from_gbp: ($f.bands[?fee == `0`] | [0].minimumAmount) != `null` && ($f.bands[?fee == `0`] | [0].minimumAmount) / `100` || `null`, address: address, deals: deals, new: new, sponsored: contains($s.sponsored_ids, id)}}"
  },
  "params": {
    "additionalProperties": false,
    "properties": {
      "cuisine": {
        "description": "Cuisine filter, matched against Just Eat's cuisine names, e.g. 'pizza', 'indian', 'chinese', 'sushi', 'vegan'",
        "maxLength": 40,
        "type": "string"
      },
      "include_sponsored": {
        "default": false,
        "description": "Keep paid sponsored placements (marked sponsored: true)",
        "type": "boolean"
      },
      "limit": {
        "default": 25,
        "description": "Maximum restaurants returned (5, 10, 25 or 50)",
        "enum": [
          5,
          10,
          25,
          50
        ],
        "type": "integer"
      },
      "name": {
        "description": "Only restaurants whose name contains this text",
        "maxLength": 60,
        "type": "string"
      },
      "open_now": {
        "default": true,
        "description": "Only restaurants open now for the chosen service",
        "type": "boolean"
      },
      "postcode": {
        "description": "Full UK postcode, e.g. 'EC4M 7RF', 'M1 1AE'",
        "pattern": "^[A-Za-z]{1,2}[0-9][A-Za-z0-9]? ?[0-9][A-Za-z]{2}$",
        "type": "string"
      },
      "service": {
        "default": "delivery",
        "description": "delivery or collection (pickup)",
        "enum": [
          "delivery",
          "collection"
        ],
        "type": "string"
      },
      "sort": {
        "default": "default",
        "description": "default = Just Eat's organic ranking; rating = best rated first, weighted by number of reviews; distance = closest first",
        "enum": [
          "default",
          "rating",
          "distance"
        ],
        "type": "string"
      }
    },
    "required": [
      "postcode"
    ],
    "type": "object"
  },
  "provenance": {
    "method": "browser-inspect",
    "notes": "Adapted from lieferando.de/search-restaurants (Just Eat Takeaway platform). The UK site uses its own API host, uk.api.just-eat.io (Just Eat's API; CORS allows www.just-eat.co.uk), with a postcode endpoint, so no address lookup is needed: /discovery/uk/restaurants/enriched/bypostcode/<POSTCODE> returns the same shape as the EU discovery API (restaurants, deliveryFees in pence, promotedPlacement). Paid placements are promotedPlacement.restaurants (defaultPromoted); the older sponsored.all.lists shape is read too. The EU gateway answers 404 for 'uk'. Menu links follow just-eat.co.uk's URL scheme (/restaurants-<uniqueName>/menu); the site's pages answer servers with a Cloudflare challenge, so the pattern was not fetched from a server. v2 (2026-11-08 08:34): verify only (the example now lists restaurants whether or not they are open (open_now false): the daily server check runs at 05:00, when no sushi or pizza place near the example address is open, and failed with 0 restaurants); requests and output unchanged.",
    "recorded_at": "2026-11-07T22:14:00+01:00",
    "recorded_by": "C4"
  },
  "requires_login": false,
  "schema": "https://wield.run/schema/recipe/v1.json",
  "site": {
    "country": "GB",
    "id": "just-eat.co.uk",
    "language": "en",
    "name": "Just Eat",
    "origin": "https://www.just-eat.co.uk",
    "origins": [
      "https://uk.api.just-eat.io"
    ]
  },
  "steps": [
    {
      "description": "Just Eat UK's discovery API on uk.api.just-eat.io (Just Eat's own API; just-eat.co.uk calls it cross-origin), by postcode: all restaurants for the postcode in one response, fees and paid placements in top-level maps. The one-item foreach writes the postcode without spaces.",
      "expect": {
        "assert": "body.restaurants != null",
        "content_type": "json",
        "status": [
          200
        ]
      },
      "extract": {
        "json": {
          "all": "sort_by(restaurants[?isTestRestaurant != `true`], &defaultDisplayRank)[].{id: id, name: name, url: join('', ['https://www.just-eat.co.uk/restaurants-', uniqueName, '/menu']), cuisines: keys(from_items(zip(cuisines[].name, cuisines[].name))), cuisine_keys: cuisines[].uniqueName, rating: rating.starRating, rating_count: rating.count, open_delivery: isOpenNowForDelivery, open_collection: isOpenNowForCollection, offline: isTemporarilyOffline, eta_min_from: deliveryEtaMinutes.rangeLower, eta_min_to: deliveryEtaMinutes.rangeUpper, distance_m: driveDistanceMeters, address: join(', ', [address.firstLine || '', join(' ', [address.postalCode || '', address.city || ''])]), deals: keys(from_items(zip(deals[?trim(description) != ''].trim(description), deals[?trim(description) != ''].trim(description)))), new: isNew}",
          "area": "metaData.area",
          "fees": "values(deliveryFees.restaurants || `{}`)",
          "postal_code": "metaData.postalCode",
          "sponsored_ids": "values(promotedPlacement.restaurants || `{}`)[?defaultPromoted].restaurantId || keys(sponsored.all.lists || `{}`)"
        }
      },
      "foreach": {
        "as": "f",
        "in": "[{pc: replace(upper(trim(params.postcode)), ' ', '')}]",
        "max": 1
      },
      "id": "restaurants",
      "request": {
        "credentials": "omit",
        "headers": {
          "Accept": "application/json"
        },
        "method": "GET",
        "query": {
          "ratingsOutOfFive": "true",
          "serviceType": "{{params.service}}",
          "vertical": "all"
        },
        "url": "https://uk.api.just-eat.io/discovery/uk/restaurants/enriched/bypostcode/{{f.pc}}"
      }
    }
  ],
  "task": "Find restaurants that deliver to a UK postcode (Just Eat)",
  "tos": {
    "notes": "Just Eat's terms prohibit scraping and automated systematic retrieval. One user-initiated search at a time from the user's own browser (1 request). Ordering stays on just-eat.co.uk.",
    "reviewed": false
  },
  "verify": {
    "checks": [
      "length(output.restaurants) > `0`",
      "output.total >= length(output.restaurants)",
      "output.area == 'London'",
      "length(output.restaurants[?sponsored]) == `0`",
      "length(output.restaurants[?open_now == `true` || open_now == `false`]) == length(output.restaurants)",
      "starts_with(output.restaurants[0].url, 'https://www.just-eat.co.uk/restaurants-')",
      "output.restaurants[0].min_order_gbp != `null`"
    ],
    "example_params": {
      "cuisine": "pizza",
      "limit": 10,
      "open_now": false,
      "postcode": "EC4M 7RF"
    },
    "max_ms": 8000
  },
  "version": 2
}