# IAPMO R\&T Product Listing Directory (`tehsnarf/iapmo-rt-product-listing-directory`) Actor

Scrapes IAPMO R\&T's public MyPLC product certification directory — plumbing, mechanical, and water-system product listings with certificate, manufacturer, and standard metadata.

- **URL**: https://apify.com/tehsnarf/iapmo-rt-product-listing-directory.md
- **Developed by:** [Chris Hoover](https://apify.com/tehsnarf) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 44.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

### What does IAPMO R&T Product Listing Directory do?

**IAPMO R&T Product Listing Directory** extracts product certification records from
[IAPMO R&T's public MyPLC directory](https://pld.iapmo.org/) — the certification database IAPMO
maintains for plumbing, mechanical, and water-system products across the US, Canada, and Mexico.
Give it one or more searches (by listee/manufacturer name, product description, standard, file
number, brand name, or listed model) and it returns structured JSON records: project/file number,
manufacturer, product description, applicable standard, certification status, and a direct link to
the certificate. Run it on-demand from the Apify Console or API, or schedule it to re-check
certification status on a recurring basis — no proxy or browser required, since the target exposes
a clean public JSON API under the hood.

### Why use IAPMO R&T Product Listing Directory?

- **Compliance verification** — confirm a plumbing/mechanical product actually holds an active
  IAPMO R&T certification before specifying, purchasing, or listing it.
- **Competitive/market research** — pull every certified product for a given manufacturer or
  product category in one structured export.
- **Procurement and specification** — feed certification status and standard references directly
  into a BOM, spec sheet, or vendor-qualification workflow.
- **Monitoring** — schedule recurring runs to catch newly-cancelled listings or newly-added
  certifications for manufacturers you track.

### How to use IAPMO R&T Product Listing Directory

1. Click **Try for free** (or **Start**) on the Actor page.
2. In the **Input** tab, add one or more entries to `searches` — each is a `searchCategory`
   (`listee`, `productDescription`, `standard`, `fileNumber`, `listedModel`, or `brandName`), a
   `query` string, and an optional `searchType` (`all`, `exact`, or `any`; defaults to `all`).
3. Optionally set `maxItemsPerSearch` and `maxItems` to cap how many records are pulled.
4. Click **Start** and wait for the run to finish.
5. Open the **Dataset** tab (or fetch it via the API) to view or download the results as JSON,
   CSV, or Excel.

### Input

| Field | Type | Description |
|---|---|---|
| `searches` | array (required) | List of `{searchCategory, query, searchType}` objects to run |
| `maxItemsPerSearch` | integer | Max records pulled per search entry (default 100) |
| `maxItems` | integer | Overall cap across all searches combined (default 500) |

Example input:
```json
{
  "searches": [
    { "searchCategory": "listee", "query": "Kohler", "searchType": "all" },
    { "searchCategory": "productDescription", "query": "water heater", "searchType": "all" }
  ],
  "maxItemsPerSearch": 100,
  "maxItems": 500
}
````

### Output

Each dataset item is one certification record. You can download the dataset in various formats
such as JSON, HTML, CSV, or Excel. Real example from a live test run (`searchCategory: "listee"`,
`query: "Kohler"`):

```json
{
  "projectNumber": "10084",
  "clientName": "KOHLER COMPANY",
  "productDescription": "EPA WaterSense High Efficiency Flushometer-Valve Water Closets/Water Closet Flushometer Valves",
  "standardDisplayValue": "EPA WaterSense Specification for Flushometer-Valve Water Closets Version 1.0 Dated 12/17/2015",
  "clientWebsite": "http://www.kohler.com/",
  "projectStatus": "Active",
  "certificateUrl": "http://myplc.iapmo.org/certificate#/15531",
  "fileCancelled": false,
  "searchCategory": "listee",
  "searchQuery": "Kohler",
  "productFamilyTab": "Lead Plumbing",
  "sourceResultCount": 140,
  "scrapedAt": "2026-07-13T00:18:27.676326+00:00"
}
```

#### Data fields

| Field | Description |
|---|---|
| `projectNumber` | IAPMO project/file number |
| `clientName` | Listee/manufacturer name |
| `productDescription` | Product description text |
| `standardDisplayValue` | Applicable certification standard(s) |
| `clientWebsite` | Manufacturer's website, when listed |
| `projectStatus` | Certification status (e.g. "Active") |
| `certificateUrl` | Link to the full certificate record |
| `fileCancelled` | Whether the listing has been cancelled |
| `searchCategory` / `searchQuery` | The search that produced this record |
| `productFamilyTab` | Product family grouping (`"Lead Plumbing"` for v1) |
| `sourceResultCount` | Total matching records reported by IAPMO for this search |
| `scrapedAt` | Timestamp the record was scraped (ISO 8601) |

### Pricing

This Actor charges **$6.00 per 1,000 results**. Example costs:

| Results | Cost |
|---|---|
| 100 | $0.60 |
| 500 | $3.00 |
| 1,000 | $6.00 |
| 5,000 | $30.00 |

### Tips

- Searching by `listee` (manufacturer name) is the fastest and most reliable way to pull a
  company's full certification portfolio.
- `standard`-category searches against very common terms can be slow on IAPMO's end — the Actor
  handles this gracefully (skips a timed-out page rather than failing the run), but expect longer
  run times for broad standard searches.
- Use `maxItemsPerSearch` to keep individual broad searches (e.g. a common brand name) from
  consuming your whole run budget.

### FAQ, disclaimers, and support

This Actor only reads publicly-accessible product/company/certificate metadata from IAPMO R\&T's
public directory — it does not access any account-gated MyPLC data and requires no login. Data
accuracy and availability depend on IAPMO R\&T's own systems being up to date. If you run into an
issue or need a custom variant (e.g. covering the Solar or LADWP listing areas), open an issue on
the Actor's Issues tab.

# Actor input Schema

## `searches` (type: `array`):

One or more searches to run against the MyPLC directory. Each search has a category (which field to match against), a query string, and a match mode.

## `maxItemsPerSearch` (type: `integer`):

Maximum number of result records to pull for any single search entry.

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

Overall cap on total result records pushed across all searches combined.

## Actor input object example

```json
{
  "searches": [
    {
      "searchCategory": "listee",
      "query": "Kohler",
      "searchType": "all"
    }
  ],
  "maxItemsPerSearch": 100,
  "maxItems": 500
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        {
            "searchCategory": "listee",
            "query": "Kohler",
            "searchType": "all"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tehsnarf/iapmo-rt-product-listing-directory").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 = { "searches": [{
            "searchCategory": "listee",
            "query": "Kohler",
            "searchType": "all",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("tehsnarf/iapmo-rt-product-listing-directory").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 '{
  "searches": [
    {
      "searchCategory": "listee",
      "query": "Kohler",
      "searchType": "all"
    }
  ]
}' |
apify call tehsnarf/iapmo-rt-product-listing-directory --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tehsnarf/iapmo-rt-product-listing-directory",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IAPMO R&T Product Listing Directory",
        "description": "Scrapes IAPMO R&T's public MyPLC product certification directory — plumbing, mechanical, and water-system product listings with certificate, manufacturer, and standard metadata.",
        "version": "1.0",
        "x-build-id": "3ZgMz6S31jSuf6SLk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tehsnarf~iapmo-rt-product-listing-directory/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tehsnarf-iapmo-rt-product-listing-directory",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/tehsnarf~iapmo-rt-product-listing-directory/runs": {
            "post": {
                "operationId": "runs-sync-tehsnarf-iapmo-rt-product-listing-directory",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/tehsnarf~iapmo-rt-product-listing-directory/run-sync": {
            "post": {
                "operationId": "run-sync-tehsnarf-iapmo-rt-product-listing-directory",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searches"
                ],
                "properties": {
                    "searches": {
                        "title": "Searches",
                        "type": "array",
                        "description": "One or more searches to run against the MyPLC directory. Each search has a category (which field to match against), a query string, and a match mode.",
                        "default": [
                            {
                                "searchCategory": "listee",
                                "query": "Kohler",
                                "searchType": "all"
                            }
                        ]
                    },
                    "maxItemsPerSearch": {
                        "title": "Max items per search",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of result records to pull for any single search entry.",
                        "default": 100
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Overall cap on total result records pushed across all searches combined.",
                        "default": 500
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```