How to Build a Lead List from Public Business Websites

Finding new leads often means hunting through hundreds of websites, but there’s a more systematic approach. Instead of manually copying contacts, you can automate the process: turn a list of business search terms into a clean email list inside Google Sheets. In practice, you set up two tabs in a spreadsheet — one for search queries (like “plumbers Seattle”) and one for collecting emails — then use an automated workflow to do the heavy lifting. The idea is to run searches for local business types, extract each business’s website, scan those sites for public email addresses, clean up the results, and dump them all into the sheet.

This can be a huge time-saver, but it comes with important caveats. For example, you must respect terms of service. Google’s terms explicitly forbid scraping or exporting data (like business names or addresses) from Maps outside approved APIs. In other words, don’t try to scrape Google Maps listings directly; stick to sources or APIs that allow it. The same caution applies to any site — check the site’s robots.txt or terms. In short, use only data sources you’re permitted to collect from.

Another reason this matters: leads aren’t just sitting on LinkedIn. In fact, experts note that valuable contacts “live everywhere — not just on LinkedIn.” Company websites, industry directories, event pages, and even social media profiles often contain rich contact data. If you can crawl those public pages and pick out the email addresses of relevant people (say, owners or managers), you’ll have fresh leads without buying expensive lists.

[embed]How to OpenClaw with Hostinger — Powerful 1 Click Setup Guide for Fast AI Agent Deployment How to OpenClaw with Hostinger using a powerful 1 click setup that keeps your AI agent online 24/7 with built in web…mrkarthikkn.medium.com

Below is a step-by-step breakdown of a typical lead-generation workflow using Google Sheets and simple web-scraping logic. We’ll cover how to set up the sheet, fetch search results, extract websites, scrape those sites for emails, and finally clean and export the list — all with an eye on best practices, common pitfalls, and legal considerations.

Set Up Your Google Sheet and Search Keywords

First, create a Google Sheet with exactly two tabs. One tab (call it searches) will hold your search ideas – each row is one query. A “search idea” might be a combination like “dog groomers [city name]” or “accounting firms [region]”. The other tab (call it emails) will hold the final results (just a column of emails). This mirrors the recommended setup in the workflow template: the searches tab has your target queries, the emails tab will collect whatever addresses you find.

Make sure the sheet headers are clear. The searches tab can be as simple as one column of queries; you might label it “Query” or similar. The emails tab might only need one column labeled “Email Address”. Later on, your automation (or script) will read the queries from the first tab and append scraped emails into the second. Double-check that your Google Sheets integration (via API or the automation tool’s Google Sheets node) has permission to read/write these tabs.

Starting the Workflow and Fetching Search Results

Once your sheet is ready, you can begin the automated workflow. In a tool like n8n or Zapier, you’d start with a manual trigger (for initial testing) and a Google Sheets step to read all rows from the searches tab. This gives you a simple list of search terms to process. In code, this might mean fetching the rows via the Google Sheets API.

Next comes the “search” step. You need to turn each query into a list of candidate websites. Commonly, this means performing a web search or hitting a directory. For example, you could use an HTTP request node to query Google Search API, Bing API, or an open directory (like Yelp or YellowPages) for each query. Keep this step small at first: test with a handful of terms to verify you’re getting actual business links back. The workflow guidance warns: “Use only sources you are allowed to collect from, or use an approved API instead of scraping restricted content”. So if Google’s bots are banned from scraping, try their Custom Search API instead, or use a licensed business directory API.

Whatever approach you use, the goal is the same: get a list of URLs or HTML pages that contain business listings for each search term. For instance, searching “Denver plumber” might return a Google search results page or a directory listing with several plumber websites. Feed each result page into your workflow as input for the next step.

Extract Business Website URLs

Now that you have pages of search results or directory listings, extract the actual business website links from them. In a code step, you can scan the HTML and pick out URLs. For example, in JavaScript you might match all href="http..." patterns, or if you have a Google Search JSON response, pick the link fields. Whatever method you use, filter carefully: you want the company’s own website, not internal links or irrelevant ones.

Specifically, drop anything that isn’t a real site URL. This means ignoring links that point to PDF files, image assets, tracking or affiliate redirects, or other domains like Google, Facebook, LinkedIn, etc. The guidance here was clear: “Filter out links that are not real business websites, such as static files, platform links, tracking links, or empty results”. One common approach is to use a regex or a whitelist of URL patterns. For instance, if a URL looks like https://maps.google.com or contains /static/ or ends in .jpg, skip it. The n8n workflow even suggested custom regex to exclude domains like google.com or schema.org links.

After filtering, you should end up with a clean list of business website URLs — one per search result item. At this point, it’s a good idea to dedupe the list in case your search results had overlaps. Save these URLs to an array or queue for the next phase.

Loop Through Websites with Rate Limiting

Rather than smashing all those URLs in parallel, process them one by one in a loop. This might be a simple for loop in code or a “Loop Over Items” node in an automation tool. The reason: it keeps things orderly and helps avoid being blocked. Servers will tolerate a steady trickle of requests far better than a torrent. In fact, web admins often set rate limits: if you send more than ~100 requests a minute from one IP, sites will throttle or block you.

To be safe, insert a small delay between each page fetch — perhaps 2–5 seconds. This mimics a human browsing slowly and reduces the chance of a 429 “Too Many Requests” response. A brief pause is a tiny inconvenience compared to having your IP blacklisted. If you do need to scale up later, consider using proxies or rotating user agents. But for now, think small and steady.

For each URL in your loop, make an HTTP GET request to retrieve the website’s HTML. If a request fails (server error, or a redirect to a blocked page), you should catch that and continue — no script should crash on one bad link. Log any errors for review. Otherwise, pass the HTML content to the next step: email extraction.

Extract Emails from the HTML

Inside each fetched business website, look for email addresses in the HTML. This is usually done with a regex search. Public emails often follow the usual pattern someone@company.com. For example, GeeksforGeeks shows a JavaScript snippet using the regex /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g to match email addresses in a string. In practical terms, you’d run something like:

js

Copy

const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
const emails = htmlContent.match(emailRegex) || [];

This finds all substrings that look like an email. (You may refine it to exclude super short domains or known spam domains.)

After extracting candidates, filter them. Remove any obviously invalid results (for example, strings missing an @ or “.”). Also trim whitespace and eliminate blank entries. If you find the same address multiple times on one page, keep just one. It’s common to see generic addresses like info@ or contact@ – decide if those are useful for your needs or not. If you’re targeting specific contacts, you might drop fully generic emails.

As GrowthRadars advises, “keep only valid-looking emails and remove blank values”. Some scraper tools also validate format or even ping the email domain to check MX records, but at minimum you should ensure each address fits the regex fully.

Collect all unique emails found on each site. You may get zero, one, or several addresses from a single website. Accumulate them in your list or output.

Clean and Deduplicate the Final List

After looping through all websites, you have a big list of email strings. Now is the time to clean it up before output. First, filter out any entries that aren’t actual emails (sometimes HTML comments or script code can slip in odd text). If possible, run a quick validation pass — for example, ensure every address still matches the regex pattern, that it doesn’t contain spaces or illegal characters. Discard anything that fails.

Most importantly, remove duplicates. The same email can appear on multiple sites or pages. If you export duplicates, you’ll end up sending repeated messages to one address. Deduplication can be done in code by storing addresses in a Set, or in Google Sheets with a formula like =UNIQUE(). The workflow instructions specifically stress this: “Use filtering and duplicate removal before export. This keeps the sheet clean and stops the same email from being saved many times”.

Finally, you might add a manual review step: glance over the top results to see if they make sense. Are you getting mostly generic admin@ or support@ addresses? Or do you see first.last@ real names? Depending on your outreach strategy, you may prefer one over the other. But for automation, at least ensure the data is in one column on the emails tab.

Export to Google Sheets

When your list is cleaned, append it to the second tab of your Google Sheet. In an automation tool, this is often another Google Sheets node set to “append row” or “append values”. Point it at the emails tab so each email goes into its own new row. If you’re doing this with a script, use the Sheets API to batch-update the range.

After you’ve set up the append, do a final test with just a few entries to make sure everything lands correctly. Once you’re confident, you can let the workflow run on your entire search list. However, take it slow. Start with a small list of queries and confirm that the workflow does exactly what you expect. If there are errors or some emails look wrong, fix them before scaling up. Then gradually run more keywords. This cautious approach helps avoid overshooting rate limits or accidentally violating a website’s scraping policy.

Common Mistakes and Considerations

Building this system is powerful, but there are pitfalls. One big mistake is ignoring the rules. Scraping data can feel trivial, but just because an email is visible doesn’t mean you can use it freely. Experts warn that email harvesting “should not be dumped into a campaign without thought”. Scraping the web too aggressively can trigger IP bans, and collecting emails without regard for privacy or consent can violate laws. For instance, in the EU or UK, GDPR considers many business emails as personal data unless a valid basis exists for processing. Always respect robots.txt and site terms. When in doubt, reach for official APIs or public data exports.

Another slip-up is technical: forgetting to handle rate-limiting. If you fire off hundreds of requests at once, expect to be blocked. As one source puts it, servers enforce “speed limits” on scrapers. Always use delays and batching. If your workflow tool offers retries or exponential backoff on 429 errors, enable those.

Email extraction itself can go awry. Regex tools might grab things that aren’t real email contacts, like code artifacts or templated strings. Be careful to filter out strings that aren’t genuine addresses. Also watch out for collecting the wrong type of email. For example, a contact’s inbox (like first.last@company.com) is usually better than a department email (like sales@company.com) if you need a specific lead. Many generic addresses will appear, so plan which ones you actually want to reach.

Finally, data quality is a limitation. Public websites aren’t curated databases; they can be out-of-date or incomplete. Company websites sometimes hide emails behind contact forms or image graphics (in which case regex won’t find them). There’s also geographic and industry bias: many local small businesses won’t list staff emails at all. In those cases, your workflow will simply skip them. That’s normal — just recognize that an automated scraper can’t extract what isn’t there.

My Take

Building an automated lead-list scraper can seem like a no-brainer for sales teams, but it requires care and judgment. In my experience, the most successful setups combine automation with human oversight. The tech — loops, regex, sheets — handles the grunt work of finding emails; you still need to guide it with good queries and verify that the contacts make sense.

The real art is in asking “is this email actually helpful?” rather than scraping indiscriminately. As one expert put it, making collection easier only shifts the burden to you to be deliberate about consent and usage.

Many people underestimate the legal and ethical side. They see an email on a page and think “free lead!” without thinking of context. In reality, savvy marketers balance aggression with respect.

If a business clearly publishes an address for customer contact, most jurisdictions will allow reasonable outreach. But spamming every address on the internet is a quick path to blacklists and bad optics. That balance — efficiency vs. ethics — is where it’s easy to slip up.

Looking ahead, I see web scraping and lead generation tools getting even smarter, powered by AI. Already there are services that parse pages semantically, identify roles, and handle anti-bot hurdles more gracefully. However, the tech arms race is matched by legal scrutiny.

As one analysis forecasts, the future will bring “more robust compliance frameworks” and tools to ensure ethical scraping. In practice, that means data professionals will need to stay informed on new laws and best practices.

What matters most is this: a lead list is only as good as its usability. Even a perfectly built script can fall short if the emails are out-of-date or the contacts aren’t decision-makers. So combine this automated workflow with good old-fashioned research — check LinkedIn or the company website manually when in doubt, and always personalize your outreach.

Done right, this kind of system can be a major productivity boost. But done carelessly, it can waste time or damage your reputation. Keep learning and adjusting the workflow; the goal is a high-quality pipeline, not just a big spreadsheet.

FAQs

1. Is it legal to scrape business listings or Google Maps for leads? Scraping laws vary by region, but a key rule is to respect each site’s terms. For instance, Google’s Maps terms specifically forbid exporting or scraping its content outside their approved APIs. In general, pulling publicly visible business emails for outreach can be considered a “legitimate interest” in B2B contexts, but you must still follow data protection laws (like GDPR or CAN-SPAM). The advice is: do not bypass restrictions. Use official APIs (Google Places API, Yelp API, etc.) when possible, and only scrape websites that allow it. If a site’s TOS says no scraping, don’t do it.

2. How do I format my Google Sheet for the scraping workflow? Follow a simple two-tab structure: one sheet named “searches” and one named “emails”. In the searches tab, list each search query in its own row (e.g. “Seattle dentist”, “Austin accounting firms”, etc.).

In the emails tab, just have one column (like “Email Address”) where the results will go. After you start the workflow, it will read from the first tab and automatically append found addresses into the second. Make sure your automation tool is connected with OAuth to that sheet and has the right sheet name/ID configured.

3. How can I reliably find email addresses in HTML? The standard method is pattern matching. Use a regular expression to find strings with the “@” symbol. For example, a common regex is /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g. This will catch most typical emails (like name@example.com). Run it on the raw HTML text, which will return an array of matches.

Then clean the array by removing any false positives and duplicates. It’s also wise to validate the format – for instance, ensure there’s a dot in the domain part. Finally, review common traps: some pages list placeholder or contact-form addresses (like contact@), which may not be useful for your purposes. Filtering out or de-prioritizing those is a common step.