# LabX Laboratory Equipment Scraper (`muhammadafzal/labx-laboratory-equipment-scraper`) Actor

Extract public LabX equipment listings with price, condition, seller, manufacturer, category, image, and optional detail-page data.

- **URL**: https://apify.com/muhammadafzal/labx-laboratory-equipment-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 labx listing extracteds

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

## LabX Laboratory Equipment Scraper

Extract public LabX laboratory-equipment listings for sourcing, price research, inventory monitoring, and structured AI workflows. Each dataset item is one public LabX listing with its title, price text, condition, seller, manufacturer, model, public image URL, category, and—when detail enrichment is enabled—description and listing dates.

### What it extracts

| Field | Description |
| --- | --- |
| `title`, `listingUrl`, `listingId` | Public listing identity and canonical LabX URL |
| `priceText`, `currency`, `condition` | The displayed price (or quote-only wording), detected currency, and listing condition |
| `manufacturer`, `model`, `categories` | Public equipment classification data |
| `sellerName`, `sellerUrl`, `sellerLocation` | Public seller profile information only |
| `description`, `createdAt`, `updatedAt` | Optional public detail-page information |
| `imageUrls`, `searchQuery`, `scrapedAt` | Search-card images, the discovery query, and extraction time |

### When to use it

Use this Actor when you need public LabX equipment listings for a product term such as `centrifuge`, `Agilent 1260`, or `mass spectrometer`, or when you have public LabX search/listing URLs already. It is useful for purchasing research, resale inventory discovery, competitive-price tracking, and feeding a normalized listing dataset into an AI agent.

Do not use it to submit a quote request, create listings, access an account or dashboard, obtain hidden phone/email data, or scrape websites other than `www.labx.com`. It reads public search cards and public listing pages only.

### Input

The Actor has two input modes:

1. `searchQueries` (the normal mode) creates public LabX searches.
2. `startUrls` uses your existing public LabX search or listing pages and replaces `searchQueries` when provided.

```json
{
  "searchQueries": ["centrifuge", "Agilent 1260"],
  "maxResults": 50,
  "includeDetails": true,
  "maxConcurrency": 2,
  "useApifyProxy": false
}
```

For an existing LabX search URL:

```json
{
  "startUrls": [{ "url": "https://www.labx.com/search?sw=centrifuge" }],
  "maxResults": 25,
  "includeDetails": true
}
```

| Input | Default | Notes |
| --- | --- | --- |
| `searchQueries` | `["centrifuge"]` | Up to 20 public LabX search terms. |
| `startUrls` | `[]` | Up to 20 public `https://www.labx.com/search?...` or `https://www.labx.com/item/...` URLs. |
| `maxResults` | `100` | Unique dataset records, from 1 to 1,000. |
| `includeDetails` | `true` | Visits each discovered public listing for full public fields. Turn off for faster search-card-only results. |
| `maxConcurrency` | `2` | Concurrent public requests, from 1 to 5. |
| `useApifyProxy` | `false` | Turn on only if direct public requests are consistently blocked in your run environment. |

### Output example

```json
{
  "listingId": "DIS-87025-248584",
  "title": "Forma Centrifuge 5678 Refrigerated Centrifuge",
  "listingUrl": "https://www.labx.com/item/forma-centrifuge-5678-refrigerated-centrifuge/DIS-87025-248584",
  "searchQuery": "centrifuge",
  "priceText": "Please Inquire for Price",
  "currency": null,
  "condition": "Used",
  "manufacturer": "GE",
  "model": "Forma Centrifuge 5678 Refrigerated Centrifuge",
  "sellerName": "Fortis Scientific",
  "sellerLocation": "New Jersey, US",
  "categories": ["Centrifuge - Benchtop"],
  "imageUrls": ["https://cdn.labx.com/v2/images/catalog/product/5591220/example.webp"],
  "scrapedAt": "2026-08-09T05:47:33.337Z"
}
```

Nullable values are deliberate: LabX does not expose a public price, manufacturer, or other field for every listing. The Actor does not invent missing values.

### Pricing

This Actor is configured for pay-per-event pricing: **$0.01 for each schema-valid public listing written to the dataset**. It never charges a result before `pushData` succeeds, never charges duplicate listing URLs, and will not exceed `maxResults` result events.

| Requested results | Maximum result-event cost |
| ---: | ---: |
| 25 | $0.25 |
| 100 | $1.00 |
| 1,000 | $10.00 |

Platform usage and any optional proxy cost are controlled by the Actor settings and your Apify plan. The run status displays the upper cost cap before extraction starts and the actual result-event count at completion.

### Reliability and limits

- LabX public search pages expose 25 listing cards per page. The Actor follows enough result pages to satisfy `maxResults` where public results are available.
- Detail enrichment creates one additional public-page request per listing. Use `includeDetails: false` when only title, price text, condition, image, and listing URL are needed.
- The Actor operates at a polite cap of 20 requests/minute with a default concurrency of 2.
- A valid search with no listings exits as `EMPTY` with a diagnostic summary and no result charges.
- If every request fails before any public page is read, the Actor fails honestly as `BLOCKED` and charges no result events. Retry later or enable `useApifyProxy` if appropriate.
- LabX’s markup and availability can change. The `SUMMARY` and `OUTPUT` key-value records contain warnings without adding diagnostic rows to the listing dataset.

### API usage

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('USERNAME/labx-laboratory-equipment-scraper').call({
  searchQueries: ['centrifuge'],
  maxResults: 25,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Compliance

Use this Actor only for information publicly available on LabX and in accordance with LabX terms, applicable law, and your organization’s data-use policies. Respect seller rights, do not use the Actor to bypass access controls, and use collected data responsibly.

# Actor input Schema

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

Use this when you know the equipment terms to find. Enter one or more public LabX queries, for example "centrifuge" or "Agilent 1260". Ignored when startUrls contains a supported URL. Default: \["centrifuge"].

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

Use this when you already have a public LabX URL. Accepts only https://www.labx.com/search?... or https://www.labx.com/item/... URLs; it does not crawl seller dashboards, quote forms, or authenticated pages. When present, these URLs replace searchQueries.

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

Use this to cap unique listing records written to the dataset. Range 1–1,000; default 100. Listing-result charges cannot exceed maxResults × $0.01.

## `includeDetails` (type: `boolean`):

Use this when you need seller, manufacturer, model, location, description, categories, and listed/updated dates from each public listing page. Defaults to true; disable for faster search-card-only records.

## `maxConcurrency` (type: `integer`):

Use this to limit simultaneous public LabX requests. Range 1–5; default 2. Lower values are gentler on the source website.

## `useApifyProxy` (type: `boolean`):

Enable only if direct public requests are consistently blocked in your run environment. Defaults to false to avoid unnecessary proxy usage; this option does not accept proxy credentials from input.

## Actor input object example

```json
{
  "searchQueries": [
    "centrifuge"
  ],
  "startUrls": [],
  "maxResults": 25,
  "includeDetails": true,
  "maxConcurrency": 2,
  "useApifyProxy": false
}
```

# Actor output Schema

## `results` (type: `string`):

Structured public LabX listing records.

## `summary` (type: `string`):

Run status, record count, result-event count, warnings, and completion timestamp.

# 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": [
        "centrifuge"
    ],
    "startUrls": [],
    "maxResults": 25,
    "includeDetails": true,
    "maxConcurrency": 2,
    "useApifyProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/labx-laboratory-equipment-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": ["centrifuge"],
    "startUrls": [],
    "maxResults": 25,
    "includeDetails": True,
    "maxConcurrency": 2,
    "useApifyProxy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/labx-laboratory-equipment-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": [
    "centrifuge"
  ],
  "startUrls": [],
  "maxResults": 25,
  "includeDetails": true,
  "maxConcurrency": 2,
  "useApifyProxy": false
}' |
apify call muhammadafzal/labx-laboratory-equipment-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/labx-laboratory-equipment-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/7blCgXu8NVKfzG3K5/builds/ZpYv9QELFKGfw2EZx/openapi.json