# National Minimum Wage Naming Scheme Employer API (`tabulary/uk-minimum-wage-naming-scheme`) Actor

UK employers officially 'named and shamed' for underpaying the National Minimum or Living Wage, by round: employer, town, postcode district, arrears owed and workers affected, from the official gov.uk press releases.

- **URL**: https://apify.com/tabulary/uk-minimum-wage-naming-scheme.md
- **Developed by:** [Tabulary](https://apify.com/tabulary) (community)
- **Categories:** Business, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 employer listings

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does National Minimum Wage Naming Scheme Employer API do?

This tool returns the UK government's official **minimum wage naming scheme** data: the periodic
rounds in which the Department for Business and Trade **names and shames** employers found to
have underpaid the **National Minimum Wage** or National Living Wage. Each record is one named
employer from one round, with their location, arrears owed and workers affected, sourced directly
from the official press release on [www.gov.uk](https://www.gov.uk). HR teams, compliance and due-
diligence researchers, journalists and payroll advisers use it to check whether a company has ever
been named, and to track each new round as it is published.

### What you get

- **Employer**: name, town/location and postcode district as published (outward code only, e.g.
  `BB1` - the source never gives a full address or postcode). Companies, charities, schools,
  councils and other organisations are named; sole traders and partners the source names as
  people are not (see "No named individuals" below).
- **The underpayment**: arrears owed (£) and number of workers affected.
- **The round**: round number, the date it was published, and a link back to the official press
  release for every record, plus the original published sentence for every employer so you can
  always check a record against the source.
- Filter by employer name or fetch one specific round by number.
- An only-new alert mode so a scheduled run only returns rounds published since the last run.
- Export to JSON, CSV or Excel, or push straight to Google Sheets; usable from AI agents through
  the Apify MCP server.

#### Alerts: only new rounds

Turn on **Only new rounds since last run** and schedule the Actor (e.g. weekly). It remembers the
highest round number it has already delivered for your employer filter and, on later runs, returns
only naming rounds published since then - so a scheduled run never re-sends the same round twice.

### How much does it cost?

You pay per employer record saved, with no monthly fee: **$3.00 per 1,000 records** on Apify's free
plan, and 10-40% less on paid Apify plans. Each run also costs $0.001 to start. Apify's free plan
includes $5 of credit every month, enough for about 1,650 records. Prices as of October 2026; the
price shown on this page is the one that applies.

| Use | Records | Cost on the free plan |
|---|---|---|
| The latest naming round | ~650 | about $1.95 |
| One past round by number | ~250-650 (varies by round) | about $0.75-$1.95 |
| A weekly scheduled alert run (new rounds only) | ~0-650 a month | about $0-$1.95 a month |

Set **Maximum cost per run** to cap any run; the Actor stops cleanly at the cap and keeps
everything it saved.

### Ready-made inputs

```json
{ "rounds": 1 }
```

The latest naming round (tested locally: Round 24, 657 employers).

```json
{ "rounds": 1, "roundNumber": 22 }
```

One specific past round by its official round number (tested locally: Round 22, 491 employers).

```json
{ "rounds": 1, "employerName": "B&Q" }
```

Only employers whose published name contains this text, in the latest round (tested locally:
matches "B\&Q LIMITED" in Round 24).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `rounds` | integer | required, prefill `1` | How many of the most recent naming rounds to fetch, newest first. Ignored if `roundNumber` is set. |
| `roundNumber` | integer | `0` | Fetch one specific round by its official number instead of the most recent ones. `0` means "use `rounds`". |
| `employerName` | string | `""` | Only return employers whose published name contains this text (case-insensitive). |
| `onlyNewSinceLastRun` | boolean | `false` | Alert mode: only return rounds published since the last run with this employer filter. |
| `maxItems` | integer | `5000` | Stop after this many employer records. |

### Output

One dataset item per named employer. A real item from a local test run (Round 24):

```json
{
  "round": 24,
  "roundDate": "2026-09-03",
  "employerName": "B&Q LIMITED",
  "nameWithheld": false,
  "location": "Eastleigh",
  "postcodeDistrict": "SO53",
  "arrearsGbp": 456934.72,
  "workersAffected": 4530,
  "sourceUrl": "https://www.gov.uk/government/news/short-changing-staff-isnt-a-shortcut-to-success-nearly-660-employers-announced-as-failing-to-pay-the-minimum-wage",
  "rawListing": "1. B&Q LIMITED, Eastleigh, SO53, failed to pay £456,934.72 to 4,530 workers."
}
```

`location` is `null` when the source publishes no town for that employer. `postcodeDistrict` is
the outward code only (no full postcode is published). A handful of employer names published by
the source themselves contain a comma (mostly NHS trusts, e.g. "St George's, Epsom and St
Helier..."); for those the `employerName`/`location` split may not be exact - `rawListing` always
has the original published sentence, unedited, so you can check any record against the source.

For a listing whose employer is a named person, `nameWithheld` is `true` and `employerName`,
`location` and `rawListing` are `null`; the round, postcode district, arrears, workers affected and
source link are kept, so totals per round stay complete.

### Use it from AI agents

Add the Actor to Claude, ChatGPT, Cursor or any MCP client through the Apify MCP server
(`https://mcp.apify.com?tools=tabulary/uk-minimum-wage-naming-scheme`). Ask in plain language, for
example: "Has B\&Q ever been named in the UK minimum wage naming scheme?" The agent fills in the
input and gets structured records back.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/tabulary~uk-minimum-wage-naming-scheme/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"rounds": 1}'
```

The same works with the Apify Python and JavaScript clients. See the API tab for details.

### Data source and limits

- Source: [www.gov.uk](https://www.gov.uk), via the public [GOV.UK Search API](https://www.gov.uk/api/search.json)
  and content API (no key, no login). [Terms](https://www.gov.uk/help/terms-conditions) and
  content are published under the [Open Government Licence](https://www.nationalarchives.gov.uk/doc/open-government-licence/).
- There is no dedicated API or index for the naming scheme: each round is one Department for
  Business press release, found by searching recent press releases and checking which ones list
  employers. This Actor scans up to the 40 most recent Department for Business press releases per
  run; a round that is older than that (roughly a year or more back) will not be found by
  `roundNumber`, and the Actor says so rather than returning nothing silently.
- The employer list is parsed from the press release's own published text, not from the attached
  spreadsheet. The source has changed this text's exact formatting between rounds (a plain list vs
  a table) without changing its wording, which this Actor already handles; a future wording change
  could require an update.
- The underlying government department has changed name mid-scheme; this Actor checks press
  releases under both its current and previous name so a rename does not stop new rounds being
  found. A further rename would need a code update.
- No named individuals: the source also names sole traders and partners as people (about 8% of
  a round, e.g. "Mr A Smith"), and the Open Government Licence does not cover personal data. A
  name is kept only when it is clearly an organisation (Ltd, PLC, LLP, CIC, school, council, trust,
  charity and similar) and carries no personal title; otherwise it is withheld. A few trading names
  without such a marker are withheld too. The source never names individual workers.
- Not affiliated with or endorsed by the Department for Business and Trade or any other publisher.

### Other Tabulary tools

Clean data from official and public sources, priced per result:

- [UK Payment Practices Report API](https://apify.com/tabulary/uk-payment-practices-reports)
- [UK Modern Slavery Statements](https://apify.com/tabulary/uk-modern-slavery-statements)
- [UK Gender Pay Gap Reports](https://apify.com/tabulary/uk-gender-pay-gap-reports)

### FAQ

**Is this data official?** Yes. Every record comes from the Department for Business and Trade's
own published press release on gov.uk, word for word.

**How far back does it go?** As far back as a naming round can still be found among the most
recent ~40 Department for Business press releases - in practice roughly a year or more. Use
`roundNumber` to try a specific past round; the Actor tells you plainly if it can't be found in
that window rather than returning nothing.

**Why is `location` sometimes missing or combined oddly with the employer name?** The source
itself publishes a flat, comma-separated sentence per employer with no fixed structure. This
Actor splits it as "name, then location", which is right for the vast majority of employers but
can be imperfect for the few names that themselves contain a comma. `rawListing` always has the
untouched original text.

**Why are some employer names withheld?** They name a person rather than an organisation (sole
traders and partnerships). Tabulary does not republish lists of named people; the row's arrears,
workers affected and postcode district are still included, and `sourceUrl` links to the original
announcement.

**Something broke?** Open an issue on the Issues tab. The Actor is tested daily.

### Changelog

- **2026-11-02:** employers named as people (sole traders, partners) are now withheld:
  `nameWithheld` is `true` and the name, location and raw line are left out.

- **2026-10-31:** first version: discovers each naming round via the official GOV.UK Search API
  and parses the employer list straight from the press release, with filters by employer name or
  round number and an only-new alert mode by round number.

### About Tabulary

This tool is part of [Tabulary](https://apify.com/tabulary): clean tables from official public
sources. Every Tabulary tool uses the source's official API or open data where one exists,
collects no personal data, and is tested on Apify every day. Questions or ideas? Open an issue on
the Issues tab.

# Actor input Schema

## `rounds` (type: `integer`):

How many of the most recent official 'naming and shaming' rounds to fetch, newest first. Each round lists several hundred employers. Ignored if "roundNumber" is set.

## `roundNumber` (type: `integer`):

Fetch one specific naming round by its official round number (e.g. 23), instead of the most recent rounds. Leave at 0 to use "Number of recent naming rounds" instead. Only rounds found among the most recent Department for Business press releases can be returned.

## `employerName` (type: `string`):

Only return employers whose published name contains this text (case-insensitive). Names of individuals (sole traders, partners) are withheld, so they cannot be searched. Leave empty for every employer in the selected round(s).

## `onlyNewSinceLastRun` (type: `boolean`):

Alert mode: remember the highest round number already delivered for this employer filter, and only return rounds published since then. The first run returns the most recent round(s).

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

Stop after this many employer records. Each record is one billable dataset item.

## Actor input object example

```json
{
  "rounds": 1,
  "roundNumber": 0,
  "employerName": "",
  "onlyNewSinceLastRun": false,
  "maxItems": 5000
}
```

# Actor output Schema

## `overview` (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 = {
    "rounds": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("tabulary/uk-minimum-wage-naming-scheme").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 = { "rounds": 1 }

# Run the Actor and wait for it to finish
run = client.actor("tabulary/uk-minimum-wage-naming-scheme").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 '{
  "rounds": 1
}' |
apify call tabulary/uk-minimum-wage-naming-scheme --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tabulary/uk-minimum-wage-naming-scheme"
        }
    }
}
```

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/UK0x3aevwARTzNej4/builds/KAEGzihInRi9zxRnv/openapi.json