# BPI Certified Compostable Products Catalog (`tehsnarf/bpi-certified-compostable-products`) Actor

Extracts BPI's public certified-compostable-products catalog (company, brand, SKU, category, thickness, home-compostable status) via the site's own public search endpoint.

- **URL**: https://apify.com/tehsnarf/bpi-certified-compostable-products.md
- **Developed by:** [Chris Hoover](https://apify.com/tehsnarf) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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.

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

Scrapes **[BPI's Certified Compostable Products catalog](https://products.bpiworld.org/)** — the
full public database of BPI-approved compostable products and licensed companies, down to
individual SKU/item number — into clean, structured JSON. Data comes directly from the site's own
public search endpoint, so every run returns current, accurate certification data rather than a
partial page scrape.

### Why use this Actor?

BPI certification confirms a product is independently verified as compostable in industrial (and,
where marked, home) composting conditions. This Actor is useful for:

- **Foodservice and packaging buyers** sourcing verified compostable bags, cups, containers, and
  cutlery by category or subcategory.
- **Sustainability and procurement teams** confirming a supplier's product actually carries active
  BPI certification before listing it as compostable.
- **Compost facility operators and municipal programs** cross-referencing accepted brands/SKUs
  against BPI's official list.
- **AI agents and research pipelines** that need machine-readable certification data instead of
  manually paging through the BPI site's search UI.

### How to use this Actor

1. Click **Try for free** (or **Run**) on this Actor's page.
2. Optionally set a **Keyword** (company, product, brand, or SKU) and choose **Result type**
   (Product or Company).
3. Adjust **Max items** if you need more than the default 100.
4. Click **Start** and download your results as JSON, CSV, or Excel from the **Output** tab.

### Input

| Field | Type | Description |
|---|---|---|
| `keyword` | string | Search term matched against company/product/SKU/brand (optional). |
| `resultType` | string | `product` or `company` (default `product`). |
| `maxItems` | integer | Maximum number of rows to return (default 100). |
| `delaySeconds` | number | Polite delay before each page fetch (default 1.0s). |
| `concurrency` | integer | How many result pages to fetch at once (default 3). |

### Output

Each item represents one product (or company, if `resultType` is `company`):

```json
{
  "company_name": "Kinger Industry Inc",
  "company_slug": "companies/kinger-industry-inc",
  "brand": "BIOGRN",
  "sku": "BG-YW001",
  "product_name": "Yard Waste Bags",
  "category": "Bags",
  "subcategory": "Yard Waste Bags",
  "color": "Natural, Printed",
  "thickness": "320 microns",
  "home_compostable": false,
  "home_thickness": null,
  "result_type": "product",
  "source_url": "https://products.bpiworld.org/companies/kinger-industry-inc"
}
```

### Pricing

$6 per 1,000 results.

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

### Notes

- No proxies or browser automation needed — the catalog's own search form POSTs to a public JSON
  endpoint; the Actor fetches a session cookie + CSRF token from the homepage once per run, the
  same way a real browser would.
- Fetches result pages in bounded concurrency batches (`concurrency` input), each still waiting
  `delaySeconds` before requesting, so per-request politeness to the target site is unchanged
  regardless of concurrency.
- Company-only fields (`brand`, `sku`, `product_name`, `category`, `subcategory`, `color`,
  `thickness`, `home_thickness`) are `null` when `resultType` is `company`.

# Actor input Schema

## `keyword` (type: `string`):

Search term matched against company/product/SKU/brand. Leave empty to pull the full catalog in listing order.

## `resultType` (type: `string`):

Which result set to pull, mirrors the site's own 'Show results by' toggle.

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

Maximum number of rows to scrape

## `delaySeconds` (type: `number`):

Polite delay each fetch waits before requesting

## `concurrency` (type: `integer`):

How many result pages to fetch at once (each still waits delaySeconds before requesting)

## Actor input object example

```json
{
  "keyword": "",
  "resultType": "product",
  "maxItems": 100,
  "delaySeconds": 1,
  "concurrency": 3
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tehsnarf/bpi-certified-compostable-products").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("tehsnarf/bpi-certified-compostable-products").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 '{}' |
apify call tehsnarf/bpi-certified-compostable-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tehsnarf/bpi-certified-compostable-products"
        }
    }
}
```

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/dy0crFrjAv93vpuEZ/builds/YbpVASmH364qzvoPt/openapi.json