# ThomasNet Email Scraper (`email_scraper/thomasnet-email-scraper`) Actor ThomasNet Email Scraper extracts publicly indexed email addresses from ThomasNet using targeted keywords, email domains, and optional locations. Find relevant B2B contacts, suppliers, and prospects with structured results for lead generation and market research. - **URL**: https://apify.com/email\_scraper/thomasnet-email-scraper.md - **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community) - **Categories:** - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.49 / 1,000 results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ### ThomasNet Email Scraper Overview **ThomasNet Email Scraper** is an Apify Actor designed to find publicly listed email addresses associated with ThomasNet search results. It turns targeted keywords, email domain suffixes, and optional geographic terms into structured lead records containing the search keyword, result title, description, URL, and extracted email address. The **ThomasNet Email Scraper** searches Google for ThomasNet pages using combinations of your keywords and selected email domains. This approach is useful when you need targeted ThomasNet contact data without manually reviewing large numbers of search results. The **ThomasNet Email Scraper** is especially useful for B2B prospecting, lead research, supplier discovery, market research, contact discovery, and building structured datasets from publicly indexed ThomasNet information. Because results depend on what is publicly indexed and displayed in Google search results, the Actor does not guarantee that every ThomasNet profile will contain an email address. ### ThomasNet Email Scraper Features The **ThomasNet Email Scraper** provides a focused workflow for collecting email addresses from publicly indexed ThomasNet results. #### Targeted Keyword Search Enter one or more keywords or search queries. Using multiple specific terms can increase search coverage because each keyword is processed independently. For example, searches such as `Safety Equipment`, `Industrial Pumps`, `Manufacturing Equipment`, or other specific product and industry terms can be used according to your research goals. #### Email Domain Filtering The **ThomasNet Email Scraper** allows you to provide one or more email domain suffixes, such as `@gmail.com` or `@yahoo.com`. The scraper searches each keyword and domain combination separately. This makes it possible to focus extraction on the email domains that are most relevant to your workflow. #### Location Filtering You can optionally provide a country, state, city, or other geographic phrase through the location input. The location is added to the Google search query to narrow results. Leaving the location empty allows the search to run without that geographic filter. #### Exclude Words The **ThomasNet Email Scraper** supports an `excludeWords` filter for removing unwanted search-result snippets. For example, you can enter terms such as `crypto` or `onlyfans`. When an excluded term is detected in a result description, the entire snippet is skipped and its email addresses are not collected. Single words use case-insensitive whole-word matching, while phrases use case-insensitive substring matching. #### Configurable Email Target The `maxEmails` input controls how many email addresses a keyword and domain combination attempts to collect before moving forward. The value can be configured from **1 to 10,000** through the Actor input schema. On free usage, the implementation applies a separate internal maximum of **100 emails**. ### How to Use the ThomasNet Email Scraper Using the **ThomasNet Email Scraper** requires only a few practical inputs. #### 1. Enter Search Keywords Provide one or more search terms in the `keywords` array. More specific and relevant queries generally provide better targeting than a single broad term. For example: ```json { "keywords": [ "Safety Equipment", "Industrial Pumps", "Water Treatment Equipment" ] } ``` #### 2. Add Email Domains Use `customDomains` to specify the email suffixes you want the **ThomasNet Email Scraper** to search for. ```json { "customDomains": [ "@gmail.com", "@yahoo.com", "@outlook.com" ] } ``` The Actor processes each keyword-domain combination independently. #### 3. Set a Location Use the `location` field to narrow the search geographically. ```json { "location": "us" } ``` A country, state, or city may be entered manually. An empty value means no location phrase is appended to the search query. #### 4. Configure the Email Limit Set `maxEmails` according to the desired target. For example: ```json { "maxEmails": 50 } ``` The implementation treats the configured limit as a target for each keyword and domain pair. #### 5. Apply Exclusions The **ThomasNet Email Scraper** can exclude unwanted profiles through `excludeWords`. ```json { "excludeWords": [ "crypto", "onlyfans" ] } ``` The exclusion test is applied to the Google result description before email extraction. ### ThomasNet Email Scraper Data Extraction The **ThomasNet Email Scraper** builds Google search queries using the ThomasNet domain, your keyword, and your selected email domain. Conceptually, a query follows this pattern: ```text site:thomasnet.com "@domain.com" ``` When a location is supplied, the location is appended to the query. The Actor retrieves Google result pages through Apify's **GOOGLE\_SERP** proxy group, parses organic search results, examines result descriptions, and extracts email addresses matching the configured domain patterns. Email extraction is based on a pattern that supports common email characters in the local part and restricts the domain portion to the configured domain suffixes. The **ThomasNet Email Scraper** also removes duplicate email addresses during the run. This means the same discovered email is not repeatedly added to the dataset when encountered again in later search results. ### ThomasNet Email Scraper Use Cases The **ThomasNet Email Scraper** can support several practical B2B data research workflows. #### Lead Generation Sales and business development teams can use targeted product or industry keywords to discover publicly indexed contact emails. #### Supplier and Manufacturer Research ThomasNet contains business and industrial search results. Researchers can use relevant product keywords to identify companies and corresponding publicly indexed contact information. #### Market Research The collected keyword, title, description, URL, and email fields can be exported for analysis and segmentation. #### Competitor Research Specific industry or product searches can help identify businesses appearing for relevant ThomasNet searches. #### B2B Prospecting The **ThomasNet Email Scraper** can help create focused contact datasets when your search strategy is based on specific industrial products, services, or business categories. #### Data Analysis Because each result is stored as a structured dataset record, the extracted ThomasNet contact data can be filtered, reviewed, and analyzed after the run. ### ThomasNet Email Scraper Input | Input | Type | Required | Default | Description | | --------------- | ---------------- | -------- | --------------------------------------- | ------------------------------------------------------------------------------ | | `keywords` | Array of strings | Yes | `["skincSafety Equipmentare", "Pumps"]` | Keywords or search queries used to search ThomasNet through Google. | | `location` | String | No | `""` | Optional country, state, city, or geographic phrase used to narrow searches. | | `customDomains` | Array of strings | No | `["@gmail.com"]` | Email domain suffixes to search for, such as `@gmail.com` or `@yahoo.com`. | | `maxEmails` | Integer | No | `10` | Email target for each keyword and domain combination. Allowed range: 1–10,000. | | `excludeWords` | Array of strings | No | `[]` | Words or phrases that cause a search-result description to be skipped. | The `keywords` field is the only required input according to `actor.json`. For best coverage, use multiple relevant keyword variations rather than relying on one broad search term. You can combine product names, equipment types, industry terminology, and other search phrases relevant to your research. ### ThomasNet Email Scraper Output Data The **ThomasNet Email Scraper** pushes structured records incrementally to the Apify dataset. | Field | Type | Description | | ------------- | ------ | ---------------------------------------------------------------------- | | `network` | String | Identifies the source network as `ThomasNet.com`. | | `keyword` | String | The keyword associated with the search that produced the result. | | `title` | String | Title extracted from the Google organic search result. | | `description` | String | Text extracted from the search-result description/snippet. | | `url` | String | URL extracted from the organic search result. | | `email` | String | A newly discovered email address matching the selected domain pattern. | The dataset view configured by `actor.json` displays `keyword`, `title`, `description`, `url`, and `email` as the primary visible fields. The runtime implementation also writes the `network` field with the value `ThomasNet.com`. Each email record represents a discovered email associated with a parsed ThomasNet search result. The keyword helps identify why the result was found, while the title, description, and URL provide context for evaluating the record. The **ThomasNet Email Scraper** pushes results incrementally rather than waiting for the entire run to finish. This means successfully collected records are sent to the Apify dataset during processing. ### Example Input ```json { "keywords": [ "Safety Equipment", "Industrial Pumps", "Water Treatment Equipment" ], "location": "United States", "customDomains": [ "@gmail.com", "@yahoo.com" ], "maxEmails": 20, "excludeWords": [ "crypto", "onlyfans" ] } ``` This configuration creates separate search targets for each keyword and email domain combination and applies the same location, maximum target, and exclusion rules. ### Example Output ```json { "network": "ThomasNet.com", "keyword": "Industrial Pumps", "title": "Example Industrial Pump Supplier", "description": "Industrial pumps supplier contact information example@gmail.com", "url": "https://www.thomasnet.com/example", "email": "example@gmail.com" } ``` The values above illustrate the structure of a result. Actual titles, descriptions, URLs, and email addresses depend on the publicly indexed search results returned during your run. ### ThomasNet Email Scraper Pagination and Search Behavior The **ThomasNet Email Scraper** processes Google search results page by page. Each search page contains up to 10 requested results, and pagination is handled through Google's `start` parameter. The implementation can theoretically examine up to **1,000 pages for an individual keyword-domain pair**, but reaching that maximum depends on search-result availability and the Actor's stopping conditions. Processing may stop earlier when the configured email target is reached, when multiple pages produce no new emails, when empty-result pages indicate that results have ended, or when later pages become inefficient. After page 25, the Actor applies additional efficiency checks. This helps prevent excessive requests when deeper pagination produces very few new addresses. ### Data Quality and Reliability The **ThomasNet Email Scraper** works with publicly indexed Google search result information rather than directly extracting private ThomasNet account information. Email discovery therefore depends on whether a matching email address is present in the searchable result description. A business may appear in search results without exposing an email address in the snippet. The scraper also performs email de-duplication using a persistent set of previously discovered addresses. When requests fail, the scraper retries using a rotated proxy URL. After repeated consecutive fetch failures, the current keyword-domain processing sequence is stopped rather than continuing indefinitely. The Actor uses the Apify **GOOGLE\_SERP** proxy group for Google search requests. ### Resume and Persistent Progress The **ThomasNet Email Scraper** stores run progress in Apify's key-value store. The implementation records both a cursor identifying the current keyword-domain position and a set of emails already seen. This allows the Actor to maintain progress information during processing and resume from persisted state after an interruption, rather than relying exclusively on temporary in-memory state. Results are also pushed incrementally to the dataset as they are discovered. ### Search Intent and ThomasNet Email Research The **ThomasNet Email Scraper** is designed around search intent such as finding industrial businesses, discovering supplier contacts, researching manufacturers, and locating publicly indexed email addresses associated with relevant ThomasNet search results. Effective searches should reflect the way a researcher would realistically describe the target business or product. For example, combining terms such as product category, equipment type, or industry-specific wording can make the search more focused than using an extremely broad term. The **ThomasNet Email Scraper** is therefore most useful when your input keywords are aligned with a clear prospecting or research objective. ### Frequently Asked Questions #### What is the ThomasNet Email Scraper? The **ThomasNet Email Scraper** is an Apify Actor that searches Google for publicly indexed ThomasNet results and extracts email addresses matching your selected domain suffixes. #### How does the ThomasNet Email Scraper find emails? The **ThomasNet Email Scraper** builds Google searches using `site:thomasnet.com`, your keyword, and an email domain suffix, then extracts matching email addresses from parsed result descriptions. #### Can I search multiple keywords? Yes. The `keywords` input is an array, so you can provide multiple search terms or queries. Each keyword is processed separately. #### Can I search multiple email domains? Yes. You can provide multiple values in `customDomains`. Each domain is processed separately with each keyword. #### Can I target a specific country or city? Yes. The `location` field accepts a geographic string. The value is appended to the Google search query when supplied. #### What does `maxEmails` control? The **ThomasNet Email Scraper** uses `maxEmails` as the collection target for each keyword-domain combination. The input supports values from 1 through 10,000, subject to the Actor's internal free-user restriction. #### Can I exclude unwanted profiles? Yes. The `excludeWords` input allows you to specify words or phrases. Matching descriptions are skipped before email extraction. #### Does the Actor collect private ThomasNet information? No. The implementation searches publicly indexed Google results and extracts information available in those result descriptions. It does not claim access to private or restricted profile information. #### Why did my run return fewer emails than requested? The requested target is not a guarantee. Search results may contain no matching email address, Google may provide limited relevant results, filters may exclude snippets, or pagination may become unproductive. #### Does the Actor remove duplicate emails? Yes. The runtime tracks previously seen email addresses and avoids pushing the same discovered address again. #### Does the Actor use proxies? Yes. The **ThomasNet Email Scraper** initializes an Apify proxy configuration using the `GOOGLE_SERP` group and rotates the proxy URL when a retry is required. #### What output does the ThomasNet Email Scraper return? Each collected record contains `network`, `keyword`, `title`, `description`, `url`, and `email`. ### Why Use This Actor The **ThomasNet Email Scraper** turns a repetitive Google search and email-review process into an automated Apify workflow. Instead of manually opening many search results, reviewing snippets, checking matching domains, and copying contact information, the Actor performs these steps programmatically and sends discovered records to an Apify dataset. Its structured inputs make it suitable for repeatable searches, while multiple keywords and domain suffixes provide flexible targeting. Persistent progress, duplicate detection, incremental dataset output, proxy rotation, and controlled pagination are built into the implementation to make longer collection runs more manageable. Most importantly, the **ThomasNet Email Scraper** keeps the output focused on fields that are useful for evaluating and organizing discovered leads. ### API and Automation The **ThomasNet Email Scraper** runs as an Apify Actor, so its results are stored in the Actor's Apify dataset according to the configured dataset schema. You can use the standard Apify platform workflow to configure inputs, start runs, monitor execution, and access the resulting dataset. The Actor itself does not define a separate external API. Its implementation uses the Apify Actor runtime, Apify dataset storage, and Apify key-value storage for persistent progress. ### Best Practices for Better Results Use several highly relevant keywords instead of depending on a single broad phrase. Select email domains that match your prospecting strategy. Adding more domain suffixes can increase the number of keyword-domain searches performed. Avoid making the location filter unnecessarily restrictive when broader discovery is acceptable. Use `excludeWords` selectively because matching descriptions are completely skipped once an exclusion term is found. When a target is not reached, review your keywords, domains, and location before assuming that additional pagination will necessarily produce more contacts. ### ThomasNet Email Scraper for B2B Research The **ThomasNet Email Scraper** is particularly suitable for workflows where publicly indexed industrial and supplier information needs to be converted into structured contact records. By combining precise keywords with domain filtering and optional geographic targeting, you can create focused searches around specific products, equipment, industries, or business categories. The resulting dataset can then serve as a starting point for manual qualification, research, segmentation, and downstream business workflows. The quality of the final dataset depends on the availability and relevance of publicly indexed ThomasNet information, so targeted search design remains an important part of the process. ### Support For questions, bug reports, feature requests, or custom development related to this Actor, use the support channels available on the Apify Actor page. For bespoke scraper development or custom modifications, the Actor documentation also provides the contact address supplied in the configuration: . The **ThomasNet Email Scraper** is designed to provide a focused, structured workflow for discovering publicly indexed ThomasNet email data through targeted search queries. # Actor input Schema ## `keywords` (type: `array`): A list of keywords or queries to search for. ## `location` (type: `string`): Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter. ## `customDomains` (type: `array`): List of custom email domains ## `maxEmails` (type: `integer`): How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed. ## `excludeWords` (type: `array`): Words or phrases you do not want to see. ## Actor input object example ```json { "keywords": [ "Supplier" ], "location": "", "customDomains": [ "@gmail.com" ], "maxEmails": 10, "excludeWords": [] } ``` # Actor output Schema ## `dataset` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "keywords": [ "Supplier" ], "location": "", "customDomains": [ "@gmail.com" ], "excludeWords": [] }; // Run the Actor and wait for it to finish const run = await client.actor("email_scraper/thomasnet-email-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "keywords": ["Supplier"], "location": "", "customDomains": ["@gmail.com"], "excludeWords": [], } # Run the Actor and wait for it to finish run = client.actor("email_scraper/thomasnet-email-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "keywords": [ "Supplier" ], "location": "", "customDomains": [ "@gmail.com" ], "excludeWords": [] }' | apify call email_scraper/thomasnet-email-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/thomasnet-email-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/PGD7kgdR59z0s7QeN/builds/3bk34zfexgjrTdbIs/openapi.json