How to Use Google Places API to Filter Businesses Without a Website

Yes — the Google Places API returns a `website` field for each business listing. When a business has no website linked to their Google Business Profile, this field is either absent or returns an empty string. This makes it possible to programmatically filter businesses by website status.

The relevant Places API fields:

Important pricing note: The `website` field is part of the "Advanced" data tier — it costs $0.017 per request (as of 2026 pricing). For every 1,000 businesses you check for websites, the cost is approximately $17. At scale, this adds up — which is why tools like B2BLeadFinder (which pre-caches this data) are more cost-efficient for prospecting.

Here's a complete walkthrough for filtering no-website businesses using the Google Places API (New).

Prerequisites:

Step 1: Text Search Request

Use the Places API Text Search to find businesses in a city:

```

POST https://places.googleapis.com/v1/places:searchText

Content-Type: application/json

X-Goog-Api-Key: YOUR_API_KEY

X-Goog-FieldMask: places.id,places.displayName,places.websiteUri,places.nationalPhoneNumber,places.formattedAddress,places.rating,places.userRatingCount

{

"textQuery": "hair salons in Birmingham UK",

"maxResultCount": 20

}

```

Step 2: Filter Where websiteUri is Absent

The response returns a `places` array. Filter for entries missing `websiteUri`:

```javascript

const noWebsiteBusinesses = places.filter(place => !place.websiteUri);

```

Step 3: Pagination for More Results

Add `pageToken` to get the next page (up to 60 results total per query):

```javascript

// In your request body:

{ "pageToken": response.nextPageToken }

```

Step 4: Export to CSV

Map the filtered results to a CSV-ready structure:

```javascript

const csvRows = noWebsiteBusinesses.map(p => ({

name: p.displayName.text,

phone: p.nationalPhoneNumber || '',

address: p.formattedAddress,

rating: p.rating || 0,

reviews: p.userRatingCount || 0,

website: 'NONE'

}));

```

The Google Places API is a powerful tool, but it has specific limitations that matter for business prospecting.

Limitation 1: 60 results per search query

A single text search query returns a maximum of 60 results (3 pages × 20 results). To cover a large city with many businesses, you need to split searches by sub-area or use multiple category queries.

Limitation 2: Cost at scale

At $0.017 per Place Details request for the website field, scanning 10,000 businesses costs $170. For an agency prospecting weekly, monthly API costs can reach $500–$2,000.

Limitation 3: No built-in lead scoring

The API returns raw data. It doesn't tell you which businesses are the best leads. You need to build your own scoring logic (or use a tool that already has it).

Limitation 4: No decision-maker data

The Places API doesn't return owner names, personal email addresses, or LinkedIn profiles. Enriching leads with decision-maker contact data requires additional API calls (People Data Labs, Hunter.io, etc.) or manual research.

Limitation 5: Requires ongoing maintenance

API versions change, billing changes, rate limits change. Using the Places API for ongoing prospecting means maintaining and monitoring code.

The practical alternative:

B2BLeadFinder wraps the Google Places API (and enriches it with additional signals) into a no-code interface. It handles pagination, cost management, scoring, and decision-maker enrichment — so you get the output of a custom Places API integration without the engineering overhead.

For developers who want full control, here's a complete Node.js script that finds businesses without websites using the Google Places API.

```javascript

const axios = require('axios');

const API_KEY = process.env.GOOGLE_PLACES_API_KEY;

const BASE_URL = 'https://places.googleapis.com/v1/places:searchText';

async function findBusinessesWithoutWebsites(query, maxPages = 3) {

const results = [];

let pageToken = null;

for (let page = 0; page < maxPages; page++) {

const body = { textQuery: query, maxResultCount: 20 };

if (pageToken) body.pageToken = pageToken;

const response = await axios.post(BASE_URL, body, {

headers: {

'Content-Type': 'application/json',

'X-Goog-Api-Key': API_KEY,

'X-Goog-FieldMask': [

'places.id',

'places.displayName',

'places.websiteUri',

'places.nationalPhoneNumber',

'places.formattedAddress',

'places.rating',

'places.userRatingCount',

'nextPageToken'

].join(',')

}

});

const { places = [], nextPageToken } = response.data;

// Filter businesses with no website

const noWebsite = places.filter(p => !p.websiteUri);

results.push(...noWebsite);

if (!nextPageToken) break;

pageToken = nextPageToken;

await new Promise(r => setTimeout(r, 2000)); // Respect rate limits

}

return results;

}

// Usage

findBusinessesWithoutWebsites('plumbers in Manchester UK')

.then(leads => {

leads.forEach(lead => {

console.log({

name: lead.displayName?.text,

phone: lead.nationalPhoneNumber,

address: lead.formattedAddress,

rating: lead.rating,

reviews: lead.userRatingCount

});

});

});

```

This script handles pagination and filters on the client side. For production use, add error handling, rate limit retry logic, and CSV export.

Choosing between building a custom Places API integration and using B2BLeadFinder comes down to your priorities.

Build your own Google Places API integration when:

Use B2BLeadFinder when:

Feature comparison:

For most agencies, the time-to-value of B2BLeadFinder outweighs the flexibility of a custom API build. For developers building lead generation products or tools for others, the raw API approach gives more control.