# UKAS Accreditation Scraper - UK Accredited Organisations (`parseforge/ukas-accreditation-scraper`) Actor

Reads the UK Accreditation Service register: every accredited organisation with its type, country, region and accreditation subtype, plus the accreditation standards, certification schemes, sectors and schedules UKAS publishes.

- **URL**: https://apify.com/parseforge/ukas-accreditation-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.45 / 1,000 accredited organisations

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### UKAS Accreditation Scraper - UK Accredited Organisations

**Scrape the UK Accreditation Service register: all 2,918 accredited organisations, with the accreditation type, country and region for each.** UKAS is the national accreditation body appointed by the UK government, and this is the list of every laboratory, certification body and inspection body it has accredited. No login, no API key. Export to CSV, JSON, Excel or XML.

Alongside the register it returns the reference collections UKAS publishes: the accreditation standards, the certification schemes, the sectors, the schedules, and the full taxonomy directory with the live count behind every term.

| Who uses it | What they scrape the UKAS register for |
|---|---|
| Compliance and quality teams | Whether a supplier's certificate comes from a genuinely accredited body |
| Procurement | A shortlist of accredited testing or inspection bodies in a region |
| Certification bodies | Who else holds accreditation in their sector, and for which standards |
| Market researchers | The shape of the UK conformity assessment market by type and region |
| Sales teams | A clean, licensed lead list of 2,918 accredited organisations |

### What it does

This Actor reads the UKAS register and returns one flat row per organisation. Every row carries:

- 🏢 **Identity:** name, UKAS slug, and the UKAS page for the organisation.
- 🔬 **Accreditation type:** Testing Laboratories, Inspection Bodies, Medical Laboratories, Certification Bodies, Calibration Laboratories, Physiological Services, Imaging Services, Reference Material Producers and the rest, plus the subtype where UKAS files one.
- 📍 **Geography:** country and UK region.
- 🗓️ **Record dates:** when UKAS published the entry and when it last changed, which is how you pull only what moved since your last run.
- 📚 **Five more outputs:** accreditation standards, certification schemes, sectors, schedules, and the taxonomy directory. Pick them with `outputs`.

Results export to CSV, JSON, Excel or XML, or stream from the API.

### What is in the register

Measured on 2026-09-02:

| | Count |
|---|---|
| Accredited organisations | 2,918 |
| Countries represented | 256 terms |
| UK regions | 13 |
| Accreditation types | 13 |
| Accreditation subtypes | 23 |
| Schedule categories | 1,997 |

Over the first 400 organisations by name, the mix runs Testing Laboratories 183, Inspection Bodies 71, Medical Laboratories 51, Certification Bodies 40, Calibration Laboratories 35, and a tail of Physiological Services, Imaging Services and Reference Material Producers. 385 of those 400 are in the United Kingdom; the rest are overseas bodies holding UKAS accreditation.

### What you can do with UKAS register data

**✅ Check an accreditation claim.**

Search a supplier's name and see whether UKAS actually accredits them, and for what.

**🔎 Build a shortlist.**

Filter by `organisationTypes` to Testing Laboratories and by `regions` to the one you need.

**🔄 Track what changed.**

Set `modifiedAfter` to your last run date and get only the entries UKAS has touched since.

**🗺️ Map the market.**

Run with `"outputs": ["taxonomies"]` for every accreditation type, subtype, country, region and schedule category with the live number of records behind it.

### Why choose this scraper

| | What you get |
|---|---|
| **The register, not a search page** | This reads the register UKAS publishes, so the count in the log is UKAS's own count for your filter, not a guess from paging. |
| **Filters that are checked before they run** | A country or type that does not match a real UKAS term is reported in the log and the run returns nothing, instead of quietly dropping the filter and billing you for the whole register. That failure mode is the one that costs money. |
| **No always empty columns** | UKAS files schedule categories against schedule instances, not against the organisation. Measured over 400 organisations, not one carried a term, so there is no `scheduleCategories` column on the organisation row. The 1,997 terms are still published, in the taxonomy output where they belong. |
| **No proxy, no browser** | Measured from the Apify container: the register is served without either. That saving is in the price. |
| **Incremental by design** | `modifiedAfter` turns a daily run into a diff instead of a re-scrape. |

### How it compares

There is no other UKAS Actor on Apify, and no other national accreditation register either. The nearest neighbours are business directory scrapers such as the BBB Actors, which cover a different question: those tell you what a business says about itself, this tells you what the national accreditation body has assessed and signed off.

| Feature | ParseForge UKAS | BBB Actors | Supplier directory Actors |
|---|---|---|---|
| National accreditation body as the source | Yes | No | No |
| Accreditation type and subtype | Yes | No | No |
| Taxonomy directory with live counts | Yes | No | No |
| Incremental by modified date | Yes | No | No |
| Price per row | $0.005 | $0.004 to $0.02 | $0.003 to $0.005 |

### What a UKAS organisation looks like

```json
{
  "rowType": "organisation",
  "organisationId": 973941,
  "name": "121 Puretesting Ltd (Trading as Pure Testing)",
  "slug": "121-puretesting-ltd-trading-as-pure-testing",
  "url": "https://www.ukas.com/organisation/121-puretesting-ltd-trading-as-pure-testing/",
  "country": "United Kingdom",
  "countries": ["United Kingdom"],
  "region": "West Midlands",
  "organisationTypes": ["Medical Laboratories"],
  "organisationSubtypes": [],
  "status": "publish",
  "publishedAt": "2021-10-13T16:15:47",
  "modifiedAt": "2021-10-13T16:17:53",
  "scrapedAt": "2026-09-02T20:52:20.759Z"
}
```

A field the source does not publish comes back as `Not Disclosed`, never as `null` and never missing.

### Configure the run

| Input | What it does |
|---|---|
| `outputs` | `organisations`, `standards`, `schemes`, `sectors`, `schedules`, `taxonomies`, or several. |
| `search` | Free text, matched by UKAS against the record. |
| `countries`, `organisationTypes`, `regions` | Names or slugs as UKAS spells them. A value that matches no term is reported rather than ignored. |
| `slugs` | Fetch specific organisations by their UKAS slug. |
| `modifiedAfter` | ISO date. Only entries changed on or after it. |
| `maxItems` | Stop after this many rows. |
| `proxyMode`, `countryCode` | Off by default, measured. |

### Pricing

Pay per event.

| Event | What it is |
|---|---|
| Accredited organisation | One organisation row. This is the price you compare. |
| Accreditation standard, Certification scheme, Sector, Schedule | One row of each reference collection. |
| Taxonomy term | One term of the taxonomy directory, with its live count. |
| API page read | One page of up to 100 records read from the register. |

### Free users

Apify free plan runs are capped at 10 rows. Paid plans run to `maxItems`.

### Run it

```json
{
  "outputs": ["organisations"],
  "organisationTypes": ["Testing Laboratories"],
  "regions": ["West Midlands"],
  "maxItems": 200
}
```

The whole register in one run is `{"outputs": ["organisations"], "maxItems": 3000}`.

### Use with AI agents (MCP)

The Actor is exposed over Apify's MCP server, so an agent can ask whether a named company holds UKAS accreditation, and for what, and get a structured answer.

### Troubleshooting

**A filter returned nothing.** Check the log. A country or type that does not match a UKAS term is named there, and the run deliberately returns nothing rather than pretending the filter was applied. Run with `"outputs": ["taxonomies"]` to see the exact spellings.

**Zero rows and a 403.** UKAS sits behind Cloudflare and reads the TLS handshake. On the Apify platform this Actor is served directly. Running the code from an address Cloudflare does not like needs `proxyMode: "datacenter"` with `countryCode: "GB"`.

**No address or contact.** UKAS does not publish those on the register API anonymously. What is published is the identity, the accreditation type and the geography, and that is what this returns.

### FAQ

**Where does the data come from?** `ukas.com`, the UK Accreditation Service, the national accreditation body appointed by the UK government.

**How current is it?** Live. Every row carries the UKAS `modifiedAt` so you can see for yourself.

**Does it include overseas bodies?** Yes. UKAS accredits organisations outside the UK and they are in the register, with their country.

**Can I get the schedule of accreditation?** The schedules collection is one of the outputs. The detailed scope inside a schedule is not published on the register API.

### Related actors

- [FINRA Arbitration Awards Scraper](https://apify.com/parseforge/finra-arbitration-awards-scraper?fpr=vmoqkp)
- [HHS OIG LEIE Exclusions Scraper](https://apify.com/parseforge/hhs-oig-leie-exclusions-scraper?fpr=vmoqkp)
- [ThomasNet Scraper](https://apify.com/parseforge/thomasnet-scraper?fpr=vmoqkp)

# Actor input Schema

## `outputs` (type: `array`):

Organisations is the accredited body directory. Standards, schemes, sectors and schedules are the reference collections UKAS publishes alongside it, and taxonomies is the controlled vocabulary with the live count behind each term.

## `search` (type: `string`):

Free text, matched by UKAS against the organisation record.

## `countries` (type: `array`):

Country names or slugs as UKAS spells them. A value that matches no term is reported instead of being ignored.

## `organisationTypes` (type: `array`):

For example Certification Body, Testing Laboratory, Inspection Body.

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

UKAS region names.

## `slugs` (type: `array`):

Fetch specific organisations by their UKAS slug.

## `modifiedAfter` (type: `string`):

ISO date, for example 2026-01-01. This is how you pull only what changed since the last run.

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

Stop after this many rows.

## `proxyMode` (type: `string`):

Measured: UKAS serves this Actor from Apify with no proxy. Turn one on only if a run starts getting blocked.

## `countryCode` (type: `string`):

Two letter country code used when a proxy is on.

## Actor input object example

```json
{
  "outputs": [
    "organisations"
  ],
  "countries": [],
  "organisationTypes": [],
  "regions": [],
  "slugs": [],
  "maxItems": 50,
  "proxyMode": "none",
  "countryCode": "GB"
}
```

# Actor output Schema

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

No description

## `csv` (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 = {
    "search": "",
    "countries": [],
    "organisationTypes": [],
    "regions": [],
    "slugs": [],
    "modifiedAfter": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ukas-accreditation-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 = {
    "search": "",
    "countries": [],
    "organisationTypes": [],
    "regions": [],
    "slugs": [],
    "modifiedAfter": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ukas-accreditation-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 '{
  "search": "",
  "countries": [],
  "organisationTypes": [],
  "regions": [],
  "slugs": [],
  "modifiedAfter": "",
  "maxItems": 50
}' |
apify call parseforge/ukas-accreditation-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/ukas-accreditation-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/7MFp4EkrIPpiyn8Ld/builds/GmcaXHi1vbCF0DNT6/openapi.json