# MCS Certified Installers Scraper (`morkerr/mcscertified-com-installer-scraper`) Actor

Scrape MCS-certified installer data from mcscertified.com. Extract contacts, certs, technology details (Solar PV, Heat Pumps, Battery Storage, Biomass, Wind), and geographic coverage for 5,500+ UK installers. Outputs structured JSON with email, phone, website, address, and coordinates. Ideal for l

- **URL**: https://apify.com/morkerr/mcscertified-com-installer-scraper.md
- **Developed by:** [morkerr](https://apify.com/morkerr) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.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/platform/actors/running/actors-in-store#pay-per-event

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## MCS Certified Installers Scraper

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://console.apify.com/actors/RX0GSUPUWoZ9f8iWQ)
[![Node.js](https://img.shields.io/badge/Node.js-20-green)](https://nodejs.org/)
[![License](https://img.shields.io/badge/License-ISC-lightgrey)]()

Scrape certified installer data from **mcscertified.com/find-an-installer/** — the official UK registry of MCS (Microgeneration Certification Scheme) certified installers. This actor extracts detailed contact information, certification details, technology specializations, and geographic coverage for thousands of renewable energy installers across the United Kingdom.

---

### Use Cases

- **Solar PV Installer Lists** — Build targeted lead lists of Solar PV certified installers by region
- **Heat Pump Market Research** — Analyze the distribution of Air Source & Ground Source Heat Pump installers across the UK
- **Competitive Analysis** — Identify certified installers in your target postcodes and service areas
- **Trade Body Auditing** — Verify certification status, certification bodies, and technology coverage
- **Green Energy Directories** — Generate clean structured data for renewable energy directories and comparison tools
- **Supply Chain Development** — Find installation partners by technology type (battery storage, biomass, solar thermal, wind turbine, etc.)

### Features

- **Technology Filtering** — Filter by 10+ renewable technology types (server-side, reduces API response)
- **Regional Filtering** — Filter by UK nation (England, Scotland, Wales, Northern Ireland) with England subregion support (client-side filtering)
- **All Contact Data** — Email, telephone, website, full address breakdown (line 1/2/3, county, postcode, country)
- **Certification Info** — Certification number, certification body, boiler upgrade scheme eligibility
- **Geographic Coordinates** — Latitude and longitude for each installer
- **Comprehensive Coverage** — Scrapes all 5,500+ certified installers in the MCS database
- **Configurable Pagination** — Set a page limit for small test runs or scrape the complete dataset
- **Clean Output** — Structured JSON in Apify dataset with consistent field naming

### Input Options

| Field | Type | Description |
|-------|------|-------------|
| `technologies` | Multi-select | Filter by renewable technology types |
| `regions` | Multi-select | Filter by UK nations (England, Scotland, Wales, Northern Ireland) |
| `englandSubregions` | Multi-select | Sub-regions within England (only applies when England is selected) |
| `maxPages` | Integer | Maximum pages to scrape (0 = all pages, ~185 pages for full dataset) |

#### Available Technology Filters

| Value | Label |
|-------|-------|
| `air-source-heat-pump` | Air Source Heat Pump |
| `battery-storage` | Battery Storage |
| `biomass` | Biomass |
| `exhaust-air-heat-pump` | Exhaust Air Heat Pump |
| `ground-water-source-heat-pump` | Ground/Water Source Heat Pump |
| `micro-chp` | Micro CHP |
| `small-wind-turbine` | Small Wind Turbine |
| `solar-assisted-heat-pump` | Solar Assisted Heat Pump |
| `solar-heating` | Solar Heating |
| `solar-pv` | Solar PV |

#### Available Region Filters

| Value | Label | Subregions |
|-------|-------|------------|
| `england` | England | Eastern, East Midlands, London, North East, North West, South East, South West, West Midlands, Yorkshire & Humberside |
| `scotland` | Scotland | — |
| `wales` | Wales | — |
| `northern-ireland` | Northern Ireland | — |

### Output Fields

Each installer record in the dataset includes:

| Field | Description |
|-------|-------------|
| `name` | Installer company name |
| `installerId` | Unique MCS installer ID |
| `slug` | URL-friendly name slug |
| `url` | Full profile URL on mcscertified.com |
| `email` | Contact email address |
| `telephone` | Contact phone number |
| `website` | Company website URL |
| `address` | Full address (combined) |
| `addressLine1` | Address line 1 |
| `addressLine2` | Address line 2 |
| `addressLine3` | Address line 3 |
| `county` | County |
| `postcode` | Postcode |
| `country` | Country |
| `certificationNumber` | MCS certification number |
| `certificationBody` | Certifying body |
| `boilerUpgradeScheme` | Boiler Upgrade Scheme eligibility (boolean) |
| `technologies` | Array of renewable technology labels |
| `regions` | Array of UK region labels |
| `lat` | Latitude coordinate |
| `lng` | Longitude coordinate |
| `distance` | Distance from search centre point |
| `technologySubType` | Technology sub-type |
| `scrapedAt` | ISO timestamp of when the record was scraped |

### How It Works

This actor communicates directly with the WordPress AJAX API that powers the mcscertified.com installer search. It does NOT use a headless browser:

1. **Nonce Extraction** — Fetches the page HTML to extract the WordPress AJAX nonce
2. **API Queries** — Sends structured GET requests to `admin-ajax.php?action=filter_installers`
3. **Server-Side Technology Filtering** — Technologies like Solar PV, Heat Pumps are filtered server-side by the API
4. **Client-Side Region Filtering** — Region filtering is applied post-query using boolean flags in the API response
5. **Dataset Output** — Each validated record is pushed to the Apify dataset

**No browser, no proxies, no heavy dependencies.** This makes the actor fast (~1 second per page), lightweight (~60MB container), and highly reliable.

### Quick Start

1. Open the actor in Apify Console: [mcscertified-com-installer-scraper](https://console.apify.com/actors/RX0GSUPUWoZ9f8iWQ)
2. Click **Start** with default settings to scrape all installers
3. Or configure filters to narrow your results
4. Export results as JSON, CSV, XML, or Excel

#### API Example

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('morkerr/mcscertified-com-installer-scraper').call({
    technologies: ['solar-pv'],
    regions: ['scotland'],
    maxPages: 10,
});

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

### Performance

- **Full scrape** (all 5,532 installers, 185 pages): ~3-4 minutes
- **Per page**: ~1 second
- **Container size**: ~60MB (Node.js 20, no browser dependencies)
- **Memory usage**: ~80MB

### Limitations

- Region filtering is applied client-side because the MCS API does not support server-side region filtering
- The MCS AJAX nonce has a 12-24 hour lifetime; the actor extracts a fresh nonce on each run
- The API returns a maximum of 30 results per page

### Changelog

#### 1.0.0

- Initial release
- AJAX API-based scraping (no browser)
- Technology and region filtering
- Complete installer data extraction

### Support

Report issues or request features via [GitHub Issues](https://github.com/anomalyco/opencode/issues).

### Disclaimer

This actor scrapes publicly available data from mcscertified.com. Users are responsible for complying with the website's terms of service and applicable data protection regulations when using scraped data.

# Actor input Schema

## `technologies` (type: `array`):

Filter by technology types. Leave empty to scrape all installers.

## `regions` (type: `array`):

Filter by UK regions. Leave empty to scrape all installers nationwide.

## `englandSubregions` (type: `array`):

Only applies when England is selected. Filter by specific English regions.

## `maxPages` (type: `integer`):

Maximum number of pages to scrape. Set to 0 to scrape all pages (5500+ installers).

## `proxyConfiguration` (type: `object`):

Proxy settings for the actor.

## Actor input object example

```json
{
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `installersDataset` (type: `string`):

Complete dataset of scraped MCS-certified installers with all fields

# 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("morkerr/mcscertified-com-installer-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("morkerr/mcscertified-com-installer-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 '{}' |
apify call morkerr/mcscertified-com-installer-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MCS Certified Installers Scraper",
        "description": "Scrape MCS-certified installer data from mcscertified.com. Extract contacts, certs, technology details (Solar PV, Heat Pumps, Battery Storage, Biomass, Wind), and geographic coverage for 5,500+ UK installers. Outputs structured JSON with email, phone, website, address, and coordinates. Ideal for l",
        "version": "1.0",
        "x-build-id": "OgLmY4RomG4WPPhUi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/morkerr~mcscertified-com-installer-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-morkerr-mcscertified-com-installer-scraper",
                "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/morkerr~mcscertified-com-installer-scraper/runs": {
            "post": {
                "operationId": "runs-sync-morkerr-mcscertified-com-installer-scraper",
                "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/morkerr~mcscertified-com-installer-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-morkerr-mcscertified-com-installer-scraper",
                "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",
                "properties": {
                    "technologies": {
                        "title": "Technology Types",
                        "type": "array",
                        "description": "Filter by technology types. Leave empty to scrape all installers.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "air-source-heat-pump",
                                "battery-storage",
                                "biomass",
                                "exhaust-air-heat-pump",
                                "ground-water-source-heat-pump",
                                "micro-chp",
                                "small-wind-turbine",
                                "solar-assisted-heat-pump",
                                "solar-heating",
                                "solar-pv"
                            ],
                            "enumTitles": [
                                "Air Source Heat Pump",
                                "Battery Storage",
                                "Biomass",
                                "Exhaust Air Heat Pump",
                                "Ground/Water Source Heat Pump",
                                "Micro CHP",
                                "Small Wind Turbine",
                                "Solar Assisted Heat Pump",
                                "Solar Heating",
                                "Solar PV"
                            ]
                        }
                    },
                    "regions": {
                        "title": "UK Regions",
                        "type": "array",
                        "description": "Filter by UK regions. Leave empty to scrape all installers nationwide.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "england",
                                "scotland",
                                "wales",
                                "northern-ireland"
                            ],
                            "enumTitles": [
                                "England",
                                "Scotland",
                                "Wales",
                                "Northern Ireland"
                            ]
                        }
                    },
                    "englandSubregions": {
                        "title": "England Subregions",
                        "type": "array",
                        "description": "Only applies when England is selected. Filter by specific English regions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "eastern",
                                "east-midlands",
                                "london",
                                "north-east",
                                "north-west",
                                "south-east",
                                "south-west",
                                "west-midlands",
                                "yorkshire-humberside"
                            ],
                            "enumTitles": [
                                "Eastern",
                                "East Midlands",
                                "London",
                                "North East",
                                "North West",
                                "South East",
                                "South West",
                                "West Midlands",
                                "Yorkshire & Humberside"
                            ]
                        }
                    },
                    "maxPages": {
                        "title": "Max Pages to Scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape. Set to 0 to scrape all pages (5500+ installers).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the actor.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
