# ThomasNet Suppliers Scraper (`khadinakbar/thomasnet-suppliers-scraper`) Actor

Scrape ThomasNet industrial suppliers by keyword, location, or URL. Returns name, phone, website, location, year founded, employees, certifications. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/thomasnet-suppliers-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 supplier scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What is ThomasNet Suppliers Scraper?

ThomasNet Suppliers Scraper is an Apify Actor for discovering ThomasNet industrial suppliers by keyword, location, category URL, or direct supplier profile URL. It accepts a single record of input per query path, and each output record represents one supplier. The most useful fields include supplier name, phone, website, location, company type, headline, source URL, and, when enrichment is enabled, year founded, employee count, annual sales, certifications, and products. The Actor is available through Apify API and Apify MCP, and it returns structured supplier records plus a run summary.

### Best fit and connected workflows

This Actor fits supplier discovery workflows that begin on ThomasNet and continue into qualification, enrichment, and review.

Use `searchQueries` when you want product-led or service-led discovery such as `cnc machining`, `sheet metal fabrication`, or `plastic injection molding`. Each keyword is searched separately across ThomasNet's North America directory.

Use `startUrls` when you already have a ThomasNet nsearch URL or a supplier profile URL and want to scrape those records directly. A profile URL is a strong starting point when a specific supplier already matters to your workflow.

Turn on `enrichDetails` when your next step benefits from profile-level fields such as description, year founded, employee count, annual sales, certifications, and products taxonomy.

This Actor also works well as the first step in a broader Apify workflow where the dataset is passed into downstream scoring, CRM preparation, or AI-assisted review.

### Practical scenario

A procurement specialist is assembling a shortlist of machine shops for a U.S. manufacturing project. They start with the keyword `cnc machining` and set `maxResults` to 25. The returned records include supplier name, phone, website, city, state, headline, company type, and profile URL. The specialist reviews those fields to identify suppliers that fit the project geography and capability, then opens the profile URL for any supplier that deserves a closer vendor review.

### Input

| Field | Type | Purpose |
|---|---|---|
| `searchQueries` | array of strings | Free-text ThomasNet searches. Each keyword is searched separately across the North America directory. |
| `startUrls` | array of strings | Direct ThomasNet nsearch URLs or supplier profile URLs. |
| `maxResults` | integer | Hard cap on the total number of suppliers scraped and billed across the run. |
| `maxPagesPerQuery` | integer | Maximum number of pages to paginate for each keyword or listing URL. |
| `enrichDetails` | boolean | Follows listing suppliers to their profile pages for profile-level fields. |
| `proxyConfiguration` | object | Proxy settings used for all requests. |

Focused JSON example:

```json
{
  "searchQueries": ["cnc machining", "sheet metal fabrication"],
  "maxResults": 20,
  "maxPagesPerQuery": 3,
  "enrichDetails": true
}
```

### Output

| Field | Type | Purpose |
|---|---|---|
| `supplierName` | string or null | Supplier name from the listing or profile. |
| `supplierId` | string or null | ThomasNet identifier extracted from the supplier profile path. |
| `profileUrl` | string or null | Canonical ThomasNet supplier profile URL. |
| `headline` | string or null | Supplier headline or summary line. |
| `companyType` | string or null | Supplier type such as manufacturer, distributor, or service provider. |
| `logoUrl` | string or null | Supplier logo image URL. |
| `city` | string or null | City from the address. |
| `state` | string or null | State or region from the address. |
| `postalCode` | string or null | Postal code. |
| `country` | string or null | Country. |
| `fullAddress` | string or null | Full address string as shown on ThomasNet. |
| `phone` | string or null | Primary phone number. |
| `website` | string or null | External company website. |
| `description` | string or null | Profile description from ThomasNet. |
| `yearFounded` | number or null | Year founded. |
| `employeeCount` | string or null | Employee count or band. |
| `annualSales` | string or null | Annual sales band. |
| `certifications` | array or null | Certifications listed on the profile. |
| `products` | array or null | Products or services taxonomy. |
| `isClaimed` | boolean or null | Claimed profile status. |
| `isAdvertiser` | boolean or null | Advertiser status. |
| `sourceUrl` | string or null | Source listing URL where the supplier was found. |
| `position` | number or null | Listing position on the page. |
| `enriched` | boolean or null | Whether the profile page was visited. |
| `scrapedAt` | string or null | Scrape timestamp. |

Illustrative dataset record:

```json
{
  "supplierName": "Example Machining Inc.",
  "supplierId": "30088334",
  "profileUrl": "https://www.thomasnet.com/company/example-machining-30088334/profile",
  "headline": "CNC machining and precision manufacturing",
  "companyType": "Manufacturer",
  "city": "Houston",
  "state": "TX",
  "phone": "+1-555-0100",
  "website": "https://example.com",
  "yearFounded": 1998,
  "employeeCount": "50-99",
  "certifications": ["ISO 9001"],
  "sourceUrl": "https://www.thomasnet.com/nsearch.html?cov=NA&searchterm=cnc%20machining",
  "position": 1,
  "enriched": true
}
```

### How it works

The Actor accepts either keyword searches or direct ThomasNet URLs.

- `searchQueries` runs each keyword through ThomasNet's nsearch and paginates listing pages up to `maxPagesPerQuery`.
- `startUrls` accepts ThomasNet nsearch result URLs and supplier profile URLs.
- `maxResults` caps the total number of suppliers scraped and billed across the full run.
- `enrichDetails` follows listing suppliers to profile pages and adds profile-level fields.
- Results are written to the default Apify dataset, and the run summary is written to the default key-value store under `OUTPUT`.
- The live contract defines three charged events: `apify-actor-start`, `supplier-scraped`, and `supplier-detail-enriched`.

### Pricing

This Actor uses Pay per event pricing and also includes Apify platform usage. The live Pricing tab is the source of truth for current pricing details.

The primary event is `Supplier scraped`, charged for each supplier card returned. When `enrichDetails` is enabled, each enriched supplier also adds a `Supplier detail enriched` event.

Example in words: if a run returns twenty supplier cards and enrichment is off, the run is billed for twenty `Supplier scraped` events plus one Actor start event. If enrichment is on, each enriched supplier adds one additional enrichment event.

Review the live Pricing tab before running large batches so the cost model matches your planned scope.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as a tool for ThomasNet supplier discovery and profile extraction. It accepts the same input fields as the Actor, returns structured supplier records, and includes a run summary for cost and count review.

Exact Actor identity: `khadinakbar/thomasnet-suppliers-scraper`

> Find ThomasNet suppliers for CNC machining in the United States. Return the first twenty suppliers, include profile details when available, and summarize the dataset records so I can review company type, location, website, and certifications.

Output interpretation:

- Use `dataset` to read the supplier records from the default Apify dataset.
- Use `summary` to review the run summary stored in the default key-value store.
- `supplier-scraped` is the billing unit for each supplier card returned.
- `supplier-detail-enriched` applies when profile pages are followed for richer fields.
- `sourceUrl` shows the listing page that produced each record, and `profileUrl` traces the supplier profile when available.

Provenance and scope:

- Records come from ThomasNet supplier listings and profile pages.
- The Actor is designed for ThomasNet supplier discovery and profile extraction.
- The scope centers on public directory data returned from the queried ThomasNet pages.

Pagination and cost guidance:

- Increase `maxPagesPerQuery` for broader coverage within a keyword or listing URL.
- Use `maxResults` as the main cost control.
- Enable `enrichDetails` when profile-level fields matter for the downstream task.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/thomasnet-suppliers-scraper').call({
  searchQueries: ['cnc machining'],
  maxResults: 5,
  enrichDetails: true,
});

const datasetItems = await client.dataset(run.defaultDatasetId).listItems();

console.log('Run ID:', run.id);
console.log('Dataset items:', datasetItems.items);
```

### Best results and outcome guidance

Use precise supplier-intent keywords such as product types, manufacturing processes, service categories, or known ThomasNet profile URLs. Set `maxResults` to the number of suppliers you want to review, and raise `maxPagesPerQuery` when you want deeper pagination for a keyword or listing page. Turn on `enrichDetails` when your review depends on profile-level fields such as certifications, year founded, employee count, or annual sales. Residential proxy settings are provided in the live input contract and are the default path for requests.

### Continue the workflow

- Then use [Universal B2B Lead Finder — Extract Emails, Phones & Business Contacts](https://apify.com/khadinakbar/universal-lead-finder) to extend ThomasNet Suppliers Scraper with a neighboring local-business research source when the brief calls for Universal data.
- Then use [Practo Doctor Scraper](https://apify.com/khadinakbar/practo-doctor-scraper) to extend ThomasNet Suppliers Scraper with a neighboring local-business research source when the brief calls for Practo data.

### Design note

I found that the live schema keeps listing-level data and profile-level enrichment in separate fields: `phone`, `website`, `headline`, and location fields are available from listings, while `description`, `yearFounded`, `employeeCount`, `annualSales`, `certifications`, and `products` appear when profile enrichment is enabled.

### FAQ

#### Can I start from a ThomasNet keyword search?

Yes. Add one or more values to `searchQueries`, and the Actor searches each keyword separately.

#### Can I start from an existing ThomasNet page?

Yes. Use `startUrls` for ThomasNet nsearch result URLs or supplier profile URLs.

#### What field should I use to identify the source page?

Use `sourceUrl`. When enrichment is available, `profileUrl` identifies the supplier profile page.

#### How do I get year founded and certifications?

Enable `enrichDetails` so the Actor follows supplier profiles and returns profile-level fields.

#### How does pagination work?

`maxPagesPerQuery` limits listing-page pagination for each search term or URL, while `maxResults` limits the total number of suppliers across the run.

#### How can I keep the run scope focused?

Start with a specific keyword or a single ThomasNet URL, then use `maxResults` and `maxPagesPerQuery` to match the number of suppliers you want to review.

### Responsible use

Use this Actor for lawful business research, supplier discovery, and workflow automation. Keep usage aligned with ThomasNet's terms and with the rights of site owners and suppliers. The Actor is intended for publicly accessible directory information and structured downstream review.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/thomasnet-suppliers-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text searches run on ThomasNet's nsearch (e.g. 'cnc machining', 'sheet metal fabrication', 'plastic injection molding'). Each keyword is searched separately across the entire North America directory and paginated up to maxPagesPerQuery. Use this for product/service-led supplier discovery. NOT a URL — to scrape a specific category, state, or city page use startUrls instead.

## `startUrls` (type: `array`):

Direct ThomasNet URLs. Supported: (1) nsearch results URLs — e.g. https://www.thomasnet.com/nsearch.html?cov=NA\&searchterm=cnc%20machining (paginated like a search); (2) supplier profile URLs — e.g. https://www.thomasnet.com/company/fruehauf-manufacturing-30088334/profile (scraped as one enriched supplier). NOT supported: /products-suppliers/ or /suppliers/usa/{state} directory URLs (these are subcategory hubs, not supplier listings — use searchQueries with a keyword instead).

## `maxResults` (type: `integer`):

Hard cap on the total number of suppliers scraped and billed across all queries and URLs. The run stops once this is reached. Defaults to 20; max 5000. Primary cost control — at $0.005/supplier basic, 20 suppliers is about $0.10. With enrichDetails on, double the cost estimate.

## `maxPagesPerQuery` (type: `integer`):

How many listing pages (about 20-30 suppliers each) to paginate through for each keyword or listing URL before moving on. Defaults to 5; max 50. Lower it to sample top results; raise it for deep coverage. Bounded again by maxResults.

## `enrichDetails` (type: `boolean`):

When true, every listing supplier is followed to its own ThomasNet profile to add full description, employee count, year founded, annual sales, certifications, products taxonomy, and additional contact details. Slower and costs an extra $0.003 per enriched supplier on top of the base $0.005. Leave false for fast listing-level data (name, phone, website, location, headline) only.

## `proxyConfiguration` (type: `object`):

Proxy used for all requests. ThomasNet uses DataDome and blocks every datacenter IP — by default this actor uses Apify Residential pinned to the US for highest success rate. Override only if you have your own residential proxy; datacenter proxies will be blocked.

## Actor input object example

```json
{
  "searchQueries": [
    "cnc machining",
    "sheet metal fabrication"
  ],
  "startUrls": [
    "https://www.thomasnet.com/nsearch.html?cov=NA&searchterm=cnc%20machining",
    "https://www.thomasnet.com/company/fruehauf-manufacturing-30088334/profile"
  ],
  "maxResults": 20,
  "maxPagesPerQuery": 5,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "cnc machining"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/thomasnet-suppliers-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["cnc machining"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/thomasnet-suppliers-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 '{
  "searchQueries": [
    "cnc machining"
  ],
  "maxResults": 20
}' |
apify call khadinakbar/thomasnet-suppliers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/thomasnet-suppliers-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 <APIFY_API_TOKEN>` 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/ZAoqDpC01eOCZ8KdQ/builds/RBlZhHbjb5TE9tcKt/openapi.json