# Fischer Connectors Catalog Scraper (`automation-lab/fischer-connectors-catalog-scraper`) Actor

Extract public Fischer connector part numbers, engineering specifications, technical documents, images, and source URLs for catalog synchronization.

- **URL**: https://apify.com/automation-lab/fischer-connectors-catalog-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.08 / 1,000 item extracteds

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/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

## Fischer Connectors Catalog Scraper

Extract the public **Fischer connectors catalog** into structured records for engineering research, distributor catalog synchronization, sourcing, and data-pipeline work. The Actor returns public part numbers when exposed, product families, electrical and mechanical specifications, technical-document links, images, and canonical Fischer source URLs.

Use a catalog search, exact part numbers, public Product Finder URLs, connector-type filters, or product-line filters. Results go to the default Apify dataset as integration-ready JSON, CSV, Excel, XML, RSS, or Parquet.

### What does this Actor do?

The Actor reads Fischer's public Product Finder and normalizes connector variants into one predictable record per catalog item. It supports:

- browsing the public catalog;
- searching names, descriptions, and part numbers;
- extracting exact product pages;
- selecting exact product lines or connector types;
- limiting output for samples or bounded synchronization jobs;
- retaining the detailed source specification fields in a `specifications` object;
- linking to public datasheets, STEP archives, drawings, and product images when available.

It does not download binary assets. It returns their public URLs, which keeps runs fast and inexpensive.

### Who is it for?

- **Electrical and mechanical engineers** comparing connector variants.
- **Distributor catalog teams** synchronizing structured manufacturer data.
- **Procurement analysts** checking public part numbers and technical attributes.
- **Product-information managers** building or refreshing PIM records.
- **Data engineers** feeding public connector metadata into warehouses or change-detection workflows.

### Why use it?

Fischer's Product Finder exposes rich fields, but manually copying thousands of connector variants is slow and error-prone. This Actor provides repeatable, typed extraction with pagination, deterministic limits, exact-source links, deduplication, and bounded transient retries. It uses the public structured catalog route directly rather than loading a browser, images, or fonts.

### What Fischer connector data can I extract?

| Field | Meaning |
| --- | --- |
| `recordId` | Stable source record identifier |
| `partNumber` | Public Fischer part number, or `null` when not exposed |
| `designation` | Official product designation |
| `description` | Public catalog description |
| `productLine` | Connector family or series |
| `seriesSize` | Published series size |
| `connectorType` | Plug, receptacle, accessory, feedthrough, or related type |
| `inStockAtDistributor` | Stock flag exposed by the linked distributor integration |
| `specifications` | Available electrical, contact, material, sealing, temperature, vibration, mounting, and other fields |
| `imageUrls` | Product, layout, dimensional, and keying images |
| `technicalDocumentUrls` | Public datasheet and STEP archive URLs |
| `sourceUrl` | Canonical Fischer Product Finder product page |
| `scrapedAt` | UTC extraction timestamp |

Source records differ by product type. Optional values may be `null`, and the contents of `specifications` vary with the fields Fischer publishes for that variant.

### How to run the Fischer Connectors Catalog Scraper

1. Open the Actor in Apify Console.
2. Enter a catalog `query`, exact `partNumbers`, or public Fischer `startUrls`.
3. Optionally add product-line or connector-type filters.
4. Set `maxItems` to the largest number of records you need.
5. Click **Start**.
6. Open the **Dataset** tab to review or export results.

A useful first run is:

```json
{
  "query": "MiniMax",
  "maxItems": 10
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `query` | string | — | Text search across the public Product Finder catalog |
| `partNumbers` | string\[] | — | Exact public Fischer part numbers, such as `108464` |
| `startUrls` | object\[] | — | Exact `my.fischerconnectors.com/product-finder/product/...` URLs |
| `productLines` | string\[] | — | Exact published product-line names, such as `MiniMax™ Series` |
| `connectorTypes` | string\[] | — | Exact types such as `Plug`, `Receptacle`, or `Accessory` |
| `maxItems` | integer | `100` | Maximum records, from 1 through 10,000 |

When exact URLs or part numbers are supplied, the Actor returns only those products that also satisfy any provided filters. Without an exact-product input, it searches or browses the catalog page by page.

### Output example

A real extracted record is shaped like this:

```json
{
  "recordId": "6a22b64f91f473344d277f19",
  "partNumber": "108464",
  "designation": "WSO 105 Z110-130+",
  "description": "Cable Mounted Right-Angle Plug Push-pull",
  "productLine": "Core Series Brass",
  "seriesSize": "105",
  "connectorType": "Plug",
  "inStockAtDistributor": false,
  "specifications": {
    "locking_system": "Push-pull",
    "housing_material": "Brass",
    "sealing_performance": "Up to IP68"
  },
  "imageUrls": [
    "https://fischerconnectors.com/app/uploads/img-pf/CO_BR_MU_LV_WSO.jpg"
  ],
  "technicalDocumentUrls": [
    "https://fischerconnectors.com/app/uploads/img-pf/Fischer_108464-wso-105-z110-130.pdf"
  ],
  "sourceUrl": "https://my.fischerconnectors.com/product-finder/product/108464-wso-105-z110-130",
  "scrapedAt": "2026-08-02T05:04:45.517Z"
}
```

The complete record can contain many more public fields inside `specifications`.

### How much does it cost to extract Fischer connector catalog records?

The Actor uses pay-per-event pricing:

- **$0.0025** once per run for the `start` event;
- the `item` event for each saved connector record;
- **$0.0018 per item on the BRONZE tier**, with lower unit rates on higher tiers.

At the BRONZE rate, 10 records cost approximately **$0.0205**, 100 cost **$0.1825**, and 1,000 cost **$1.8025**, including the run fee. Apify's active pricing tier for your account determines the exact item rate shown before the run.

Failed, rejected, duplicate, and empty records are not charged as items.

### Engineering catalog synchronization workflow

For a repeatable catalog feed:

1. Filter to the product family or connector type your catalog supports.
2. Schedule the Actor daily or weekly in Apify.
3. Export the default dataset to your warehouse, spreadsheet, PIM, or object storage.
4. Compare records by `recordId` or `partNumber` against the previous successful snapshot.
5. Review changed `specifications`, documents, and source URLs before publishing downstream.

The Actor produces current snapshots. Snapshot retention and change comparison should be handled by your task, webhook, database, or automation workflow.

### Integration ideas

- Populate connector attributes in a product information management system.
- Enrich a bill-of-materials candidate list by exact public part number.
- Build a searchable internal engineering catalog.
- Detect public datasheet or STEP-link changes between scheduled snapshots.
- Export family-specific records to Google Sheets, Airtable, BigQuery, Snowflake, or S3.
- Send a webhook after each successful run to start a downstream validation job.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fischer-connectors-catalog-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"MiniMax","maxItems":10}'
```

To wait for completion and return dataset items, use the synchronous dataset endpoint documented in the Apify API reference.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fischer-connectors-catalog-scraper').call({
  connectorTypes: ['Receptacle'],
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fischer-connectors-catalog-scraper').call(
    run_input={'partNumbers': ['108464'], 'maxItems': 1}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fischer-connectors-catalog-scraper"
```

**Claude Desktop:** open Settings → Developer → Edit Config. **Cursor:** open Settings → MCP. **VS Code:** add the server to your MCP configuration. Use this equivalent JSON:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fischer-connectors-catalog-scraper"
    }
  }
}
```

Example prompts:

- “Extract 20 Fischer MiniMax connector records with datasheet and image URLs.”
- “Get the public specification record for Fischer part number 108464.”
- “Build a 50-item feed of Fischer receptacles for catalog review.”

### Limits and responsible operation

- The Actor extracts public catalog information and does not log in.
- Maximum output is 10,000 records per run.
- Product and asset availability remains controlled by Fischer Connectors.
- Product families expose different specification keys.
- Search behavior follows the public Product Finder's current matching behavior.
- The Actor does not guarantee stock, compatibility, safety, certification, or suitability for an application.
- Treat technical data as discovery and synchronization input; verify critical decisions against current official documentation and qualified engineering review.

### Troubleshooting

**Why did my exact part number return no record?**

Confirm that the part number is publicly exposed in the current Fischer Product Finder. Some records use a public `P` identifier or expose a part number only after catalog updates.

**Why did a filter return zero records?**

`productLines` and `connectorTypes` use exact published values. Start with a small unfiltered run, copy the value from its output, and reuse it in the filter.

**Why are some fields missing or null?**

Fischer publishes different attributes for plugs, receptacles, accessories, feedthroughs, and cable assemblies. The Actor does not invent unavailable values.

**Does the Actor download PDFs, images, or STEP files?**

No. It returns public links so you can decide which assets to download and store.

### Legal and ethical use

Use this Actor only for lawful purposes and in line with Fischer Connectors' terms, applicable database and copyright rules, and Apify's policies. Do not present extracted data as an official endorsement, bypass access controls, or redistribute protected documents without the necessary rights. Minimize collection, respect source availability, keep source attribution, and independently verify safety-critical specifications.

### Related automation-lab Actors

- [McMaster-Carr Product Scraper](https://apify.com/automation-lab/mcmaster-carr-product-scraper) for another industrial product-catalog workflow.
- [GlobalSpec Industrial Product Scraper](https://apify.com/automation-lab/globalspec-industrial-product-scraper) for broader industrial product discovery.

### FAQ

**Can I scrape the full catalog?** Yes. Leave the search and exact-product inputs empty, set an appropriate `maxItems`, and schedule larger snapshots responsibly.

**Can I export to CSV or Excel?** Yes. Use the Dataset export controls or dataset API after the run.

**Can I filter by more detailed specification fields?** The current input exposes product line and connector type. Extract a bounded catalog feed and filter detailed `specifications` downstream.

**Are part numbers always present?** No. The Actor includes them only when the public source exposes them.

**Does it require a proxy?** No. The current public structured route works directly, so the Actor does not enable paid proxy traffic.

**Does it compare two runs?** No. It produces current structured snapshots that can be compared by an Apify Task, webhook consumer, database, or data pipeline.

# Actor input Schema

## `query` (type: `string`):

Optional text search across Fischer product names, descriptions, and part numbers. Leave empty to browse the catalog.

## `partNumbers` (type: `array`):

Optional exact Fischer part numbers, for example 108464. When set, only matching records are returned.

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

Optional public Fischer Product Finder product pages to extract directly.

## `productLines` (type: `array`):

Return only exact product-line names, such as MiniMax™ Series or Core Series.

## `connectorTypes` (type: `array`):

Return only exact connector types, such as Plug, Receptacle, Accessory, Feedthrough, or Pre-cabled Plug.

## `maxItems` (type: `integer`):

Maximum number of connector records saved to the dataset.

## Actor input object example

```json
{
  "query": "MiniMax",
  "maxItems": 20
}
```

# Actor output Schema

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

Default dataset with all extracted catalog records.

# 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 = {
    "query": "MiniMax",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fischer-connectors-catalog-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 = {
    "query": "MiniMax",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fischer-connectors-catalog-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 '{
  "query": "MiniMax",
  "maxItems": 20
}' |
apify call automation-lab/fischer-connectors-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fischer-connectors-catalog-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/LGUyJYUB52UcVTbme/builds/fLdaXuxeM9pgeJ1MF/openapi.json