如何突破Google Places API NearbySearch的60条结果限制？

我需要获取指定区域内的所有餐厅列表，但Google Places API的NearbySearch接口单次请求最多返回20条结果，分页最多只能拿到60条。请问有没有办法获取超过60条的结果？

我原本考虑采用网格搜索的思路，代码示例如下：

const searchRadius = 5000; 
const center = { lat: 50.262, lng: 10.970 };
const step = 0.05; 

const searches = [];
for (let latOffset = -0.2; latOffset <= 0.2; latOffset += step) {
  for (let lngOffset = -0.2; lngOffset <= 0.2; lngOffset += step) {
    searches.push({
      location: { lat: center.lat + latOffset, lng: center.lng + lngOffset },
      radius: searchRadius,
    });
  }
}

再配合极小半径按距离排序的请求，但这种方法感觉不够规范。我知道这个话题已经有不少讨论，但相关帖子都比较旧了，想了解有没有新的解决方案。查阅谷歌官方文档和StackOverflow后没找到相关内容，所以在这里咨询。

编辑补充：
我基于上述网格法做了优化，当请求结果达到上限时，会自动缩小步长后重复搜索，代码如下：

async function fetchAllPages(dbConnection, params) {
    let nextPageToken = null;
    let totalResults = 0;

    let anyInGermany = false;
    do {
        try {
            if (nextPageToken) {
                await new Promise((resolve) => setTimeout(resolve, 2000));
                params.pagetoken = nextPageToken;
            }

            const response = await client.placesNearby({params});
            const results = response.data.results;
            totalResults += results.length;

            for (const place of results) {
                const details = await getPlaceDetails(place.place_id);

                if (details && details.address.includes('Germany')) {
                    anyInGermany = true;
                    await saveToDatabase(dbConnection, details);
                } else {
                    console.log(`Übersprungen (nicht in Deutschland): ${place.name}, ${details.address}`);
                }
            }

            nextPageToken = response.data.next_page_token || null;
        } catch (error) {
            console.error(`Fehler beim Abrufen von Seiten:`, error.message);
            nextPageToken = null;
        }
    } while (nextPageToken);

    if(!anyInGermany)
        await saveInvalidCoordinate(dbConnection, params.location.lat, params.location.lng)

    return totalResults;
}

async function requestWithDynamicStep(dbConnection, lat, lng, step) {
    let currentStep = step;
    let totalResults = 0;

    while (currentStep >= MIN_STEP) {
        const coordKey = `${lat},${lng}`;

        if (invalidCoordinatesCache.has(coordKey)) {
            console.log(`Überspringe ungültige Koordinaten: ${lat}, ${lng}`);
            return;
        }

        console.log(`Suche Orte bei Lat: ${lat}, Lng: ${lng}, Schrittweite: ${currentStep}...`);

        const params = {
            location: {lat, lng},
            rankby: 'distance',
            type: 'restaurant',
            key: apiKey,
        };

        totalResults = await fetchAllPages(dbConnection, params);

        if (totalResults >= MAX_RESULTS) {
            console.log(`Limit erreicht (${totalResults} Treffer). Schrittweite verkleinern...`);
            currentStep /= 2;
        } else if (totalResults === 0) {

        } else {
            break;
        }
    }

    if (currentStep < MIN_STEP) {
        console.log(`Minimale Schrittweite erreicht bei Lat: ${lat}, Lng: ${lng}`);
    }
}

async function searchPlacesAcrossGermany() {
    const dbConnection = await mysql.createConnection(dbConfig);

    await loadInvalidCoordinates(dbConnection);

    for (let lat = GERMANY_BOUNDS.south; lat <= GERMANY_BOUNDS.north; lat += initialStep) {
        for (let lng = GERMANY_BOUNDS.west; lng <= GERMANY_BOUNDS.east; lng += initialStep) {
            await requestWithDynamicStep(dbConnection, lat, lng, initialStep);
        }
    }

    await dbConnection.end();
    console.log('Fertig mit der Suche und Speicherung!');
}

内容的提问来源于stack exchange，提问作者RobinCirex