# McMaster-Carr Scraper (`solidcode/mcmaster-scraper`) Actor

\[💰 $4.0 / 1K] Extract McMaster-Carr products from any category, search, or product URL — part numbers, prices, tiered quantity pricing, full spec tables, and images. Paste filtered URLs, add as many as you need, export to JSON, CSV, or Excel.

- **URL**: https://apify.com/solidcode/mcmaster-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## McMaster-Carr Scraper

Pull structured product data from McMaster-Carr at scale — part numbers, prices, tiered quantity price breaks, per-family spec tables, images, and direct product links for fasteners, tools, raw materials, and hardware. Paste a category page, a search, or a single product URL and get clean rows back. Built for procurement teams, mechanical engineers, and e-commerce sellers who need McMaster-Carr part data and pricing without copy-pasting it cell by cell out of the catalog.

### Why This Scraper?

- **Tiered quantity price breaks** — captures McMaster's buy-more-save-more pricing as a structured `priceBreaks` list (`minQty` + `price` per tier), so you can model bulk-order cost instead of just the unit price.
- **Per-family spec tables** — every product row carries a generic `specs` map of that family's listing columns: thread size, material, length, drive style, tensile strength, finish, and whatever else the family lists. No data is dropped because it didn't fit a fixed schema.
- **Three input types in one actor** — category pages, keyword search URLs, and direct product URLs all resolve to product rows. Mix all three in a single run.
- **Batch a list of URLs, not one at a time** — paste as many McMaster-Carr URLs as you want into one run; results are deduplicated by part number across all of them.
- **Full category pull** — point it at a leaf category like washers (~750 parts) or eyebolts and get every product row, not just the first page.
- **Optional full detail mode** — flip one switch to open each product's own page for its complete specification table, full descriptive title, qualified price string, and (where available) the primary image.
- **Orderable part numbers + direct links** — every row includes the exact McMaster SKU and a ready-to-open `mcmaster.com` product URL, so a buyer can go straight to checkout.
- **Filter-aware** — narrow by thread size, material, or any facet on McMaster first, then paste the filtered URL to scrape only the parts that match.
- **JSON, CSV, and Excel export** — every result downloads in the format your BOM tool, ERP, or spreadsheet already speaks.

### Use Cases

**Procurement & Sourcing**

- Build approved-vendor part lists with current McMaster pricing
- Capture tiered price breaks to find the cheapest order quantity
- Pull a whole category to compare options before placing a PO
- Keep an internal parts catalog in sync with McMaster SKUs

**Competitive & Price Monitoring**

- Track McMaster list prices on the parts you resell
- Benchmark your own catalog against McMaster's pricing
- Watch quantity-break thresholds for high-volume SKUs
- Spot price movement on key fasteners and hardware over time

**Engineering & BOM Building**

- Populate a bill of materials with verified part numbers and specs
- Pull thread size, material, and dimensions for component selection
- Cross-reference tensile strength and finish across a fastener family
- Attach product images and links to design documentation

**E-commerce & Catalog Enrichment**

- Enrich your storefront with McMaster part specs and images
- Fill in missing attributes (material, size, finish) on existing listings
- Map your SKUs to McMaster equivalents
- Feed clean product rows into a marketplace or PIM

**Market & Category Research**

- Map how many parts a family contains and which variants exist
- Analyze spec coverage across a product category
- Study how McMaster structures and prices an entire family
- Build datasets of industrial hardware for analysis

### Getting Started

#### Scrape One Category

The simplest run — paste a single category URL:

```json
{
    "startUrls": ["https://www.mcmaster.com/products/eyebolts/"]
}
```

#### Limit the Results

Cap how many products come back across all your URLs:

```json
{
    "startUrls": ["https://www.mcmaster.com/products/washers/"],
    "maxResults": 50
}
```

#### Full Detail Mode (Multiple URLs)

Batch a category, a search, and a product URL — and pull every product's full spec table, complete title, tiered pricing, and image:

```json
{
    "startUrls": [
        "https://www.mcmaster.com/products/socket-head-screws/",
        "https://www.mcmaster.com/search/threaded%20insert%20brass/",
        "https://www.mcmaster.com/91251A268/"
    ],
    "includeProductDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array of strings | `["https://www.mcmaster.com/products/eyebolts/"]` (example prefill) | One or more McMaster-Carr category, search, or product page URLs. Tip: apply any filters you want in your browser first, then copy the resulting URL and paste it here. A very broad top-level category is collected up to its first 150 sub-sections per run; for a complete pull of an extremely large category, scrape a more specific (leaf or filtered) URL or split it. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeProductDetails` | boolean | `false` | Open each product's own page to collect its full specification table, complete title, and main image. This gives you more data per product but takes longer and costs more. |
| `maxResults` | integer | `0` | The largest number of products to return across all your URLs. Set to `0` for no limit. |

### Output

Each product is one flat row. Listing-only runs populate the core fields and the per-family `specs` map; turning on **Include full product details** adds `titleFull`, `priceBreaks`, the full `specifications` table, and — where the product page exposes it — the product image (`imageUrl` is best-effort and may be empty for some products).

```json
{
    "partNumber": "91251A268",
    "title": "Steel Socket Head Screws",
    "titleFull": "Black-Oxide Alloy Steel Socket Head Screw, 1/4\"-20 Thread Size, 1\" Long",
    "url": "https://www.mcmaster.com/91251A268/",
    "price": "$15.16 per pack of 10",
    "priceBreaks": [
        { "minQty": 1, "price": "$15.16" },
        { "minQty": 5, "price": "$13.98" },
        { "minQty": 25, "price": "$11.42" }
    ],
    "family": "Steel Socket Head Screws",
    "specs": {
        "Thread Size": "1/4\"-20",
        "Length": "1\"",
        "Material": "Alloy Steel",
        "Finish": "Black Oxide",
        "Drive Style": "Hex"
    },
    "imageUrl": "https://images1.mcmaster.com/mvC/Contents/gfx/ImageCache/301/91251A268_image.png",
    "specifications": {
        "Tensile Strength": "180,000 psi",
        "Thread Type": "UNC",
        "Unit of Measure": "Pack of 10"
    },
    "sourceUrl": "https://www.mcmaster.com/products/socket-head-screws/",
    "scrapedAt": "2026-06-20T13:43:31.166824+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `partNumber` | string | McMaster part number — the orderable SKU. |
| `title` | string | Product or family title for the row. |
| `titleFull` | string | null | Full descriptive title (detail mode only). |
| `url` | string | Direct product URL on mcmaster.com. |
| `family` | string | Product family / category the row came from. |
| `imageUrl` | string | null | Primary product image URL — best-effort in detail mode (may be empty for some products). |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | string | null | Listed price for the row — the bare number in listing mode (e.g. "8.71") and a qualified string in detail mode (e.g. "$15.16 per pack of 10"). `null` for call-for-price products. |
| `priceBreaks` | array | null | Tiered quantity pricing as `[{minQty, price}]` (detail mode). |

#### Specifications & Metadata

| Field | Type | Description |
|-------|------|-------------|
| `specs` | object | Per-family listing columns as a key→value map (thread size, material, length, finish, etc.). Keys vary by product family. |
| `specifications` | object | null | Full detail-page specification table (detail mode only). |
| `sourceUrl` | string | The input URL this row was extracted from. |
| `scrapedAt` | string | ISO 8601 timestamp of when the row was collected. |

### Tips for Best Results

- **Filter first, then paste.** Narrow a category by thread size, material, or any facet on McMaster-Carr in your browser, then copy that filtered URL — you'll scrape only the parts you care about and pay for nothing extra.
- **Point at a leaf category, not a broad top-level one.** A specific family like "eyebolts" or "socket head screws" returns clean product rows; a very broad top-level category resolves to sub-categories that the actor will walk into for you, but a leaf family is the most direct route.
- **Turn on full details when you need specs or images.** Listing rows give you part numbers, prices, and the family's listing columns. Switch on **Include full product details** for the complete spec table, full title, tiered price breaks, and (where available) the product image — at a higher per-product cost.
- **Use `priceBreaks` to find your sweet-spot quantity.** The tiered list shows exactly where each discount kicks in, so you can size an order to land in the cheapest bracket.
- **Set `maxResults` while you test.** Start with a small cap to preview the shape of the data, then set it to `0` for a full category pull once you're happy.
- **Batch related URLs in one run.** Drop several categories, searches, and product URLs into `startUrls` together — results are deduplicated by part number, so overlapping inputs won't double up.
- **`specs` keys are family-specific.** Two different families return different column names, so map fields per family rather than assuming a fixed set across your whole dataset.

### Pricing

**From $4.00 per 1,000 results** — undercutting other McMaster-Carr extractors while returning richer data per product. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.75 | $4.50 | $4.25 | $4.00 |
| 10,000 | $47.50 | $45.00 | $42.50 | $40.00 |
| 100,000 | $475.00 | $450.00 | $425.00 | $400.00 |

A "result" is one product row in your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available product information from McMaster-Carr for legitimate business purposes such as procurement, pricing research, and catalog management. You are responsible for using the collected data in compliance with McMaster-Carr's terms of service and all applicable laws. Do not use the data to infringe intellectual property, and respect reasonable request volumes. This actor does not collect personal data.

# Actor input Schema

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

One or more McMaster-Carr category, search, or product page URLs. Tip: apply any filters you want in your browser first, then copy the resulting URL and paste it here. Note: a very broad top-level category (one that branches into many sub-categories) is collected up to its first 150 sub-sections per run; for a complete pull of an extremely large category, scrape a more specific (leaf or filtered) URL or split it into its sub-categories.

## `includeProductDetails` (type: `boolean`):

Open each product's own page to collect its full specification table, complete title, and main image. This gives you more data per product but takes longer and costs more.

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

The largest number of products to return across all your URLs. Set to 0 for no limit.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.mcmaster.com/products/eyebolts/"
  ],
  "includeProductDetails": false,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of products with key fields like part number, title, price, and link.

## `details` (type: `string`):

Full per-product rows including spec columns, tiered pricing, family, and images.

# 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 = {
    "startUrls": [
        "https://www.mcmaster.com/products/eyebolts/"
    ],
    "includeProductDetails": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/mcmaster-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 = {
    "startUrls": ["https://www.mcmaster.com/products/eyebolts/"],
    "includeProductDetails": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/mcmaster-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.mcmaster.com/products/eyebolts/"
  ],
  "includeProductDetails": false,
  "maxResults": 100
}' |
apify call solidcode/mcmaster-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/mcmaster-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lDEWlM4pwuugGMFQe/builds/BZ5ClVCUx2gTchITT/openapi.json