# UK Late Payers & Payment Practices Scraper (`battles_2026/uk-late-payer-signals`) Actor
Official UK payment practices reports joined with Companies House: days to pay, % paid late, trend vs prior report, e-invoicing / supply chain finance gaps, terms over 60 days. Filters by sector, region, size. Monitor mode returns only changes.
- **URL**: https://apify.com/battles_2026/uk-late-payer-signals.md
- **Developed by:** [Jonathan D Battles](https://apify.com/battles_2026) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $7.00 / 1,000 company-signals
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
## UK Late Payers & Payment Practices Scraper
**Find out which large UK companies pay their suppliers late, which are getting worse, and which offer no e-invoicing or supply chain finance.** Each company becomes one clean, cited row, built from the UK government's official payment practices reports and joined with Companies House data.
### What is UK Late-Payer & AP-Prospect Signals?
Under UK law, large companies and LLPs must report how quickly they pay suppliers every six months. This Actor turns that statutory dataset, more than 115,000 reports from more than 10,000 companies, into ready-to-use, cited signals for prospecting, credit screening and research.
### What data does it return?
- **Average days to pay** and the **change since the company's previous report**
- **% of invoices paid late** (not within agreed terms) and **% paid after 60 days**
- **Trend**: `WORSENING`, `IMPROVING`, `STABLE`, `NO_PRIOR_REPORT` or `NO_PAYMENT_DATA`
- **Gaps you can sell into**: no e-invoicing, no supply chain finance, payment terms over 60 days (the cap proposed in the Commercial Payments Bill)
- **Companies House context**: SIC codes (sector), status (e.g. *Liquidation*), accounts category (size), town and region
- A transparent **late-payment score from 0 to 100**
- **Monitor mode** returns *only what changed* since your last run, so you can schedule it and get alerts
Every row links to the official report on gov.uk, so you can show your source.
### How much does it cost to get UK late-payer data?
- **Company signal: $0.01** per company row (Bronze $0.009, Silver $0.008, Gold $0.007 per row on Apify's paid tiers) in snapshot mode (rows whose Companies House check could not be done, status `not-checked-time-limit` or `unavailable`, are free)
- **Change alert: $0.05** per changed company in monitor mode
- Baseline monitor runs and runs with no changes cost nothing beyond the Actor start.
`maxResults` (default 100) and your run's maximum charge both cap spend. The Actor stops exactly at your limit. Monitor alerts over the cap are kept and delivered on your next run.
Typical costs at the $0.01 base price: a 20-row run is $0.20; 100 prospects $1.00; every reporting company (about 10,000) about $103. Platform compute is included; you pay only the events above.
### How to use it
1. Open the **Input** tab, pick **Snapshot** (a list) or **Monitor** (alerts), and set filters such as sector (SIC prefix), region or minimum days to pay.
2. Set **Max results** to cap rows and cost, then click **Start**.
3. Download the results as JSON, CSV or Excel, or use the dataset views **AP / SCF prospects**, **Late payers** and **Changes**. To get alerts, schedule a monitor run weekly.
#### Who uses this
| You are... | Use it to... |
|---|---|
| An **AP automation / e-invoicing vendor** | Build prospect lists of large UK firms that pay late and don't offer e-invoicing (`onlyNoEInvoicing`) |
| A **supply chain finance / early-payment provider** | Find buyers with long terms and no SCF programme (`onlyNoSupplyChainFinance`, `minMaxContractualTermDays: 61`) |
| An **invoice finance lender or credit insurer** | Screen debtors and get alerts when a debtor's payment performance worsens or it enters administration |
| An **SME supplier or sales team** | Check how a prospective customer really pays before you sign |
| A **journalist or researcher** | Track late payers and sector trends ahead of the Commercial Payments Bill |
#### Quick start
**Construction late payers in London and the North West without e-invoicing (large companies only):**
```json
{
"mode": "snapshot",
"sicPrefixes": ["41", "42", "43"],
"regions": ["London", "North West"],
"accountsCategories": ["FULL", "GROUP"],
"minAvgDaysToPay": 45,
"onlyNoEInvoicing": true,
"activeOnly": true,
"maxResults": 500
}
```
**Weekly alerts on your debtor book:**
```json
{
"mode": "monitor",
"watchlistName": "my-debtors",
"companyNumbers": ["00784278", "SC012921", "04472486"],
"maxReportAgeMonths": 0
}
```
The first monitor run only saves a baseline (no charge). Each later run returns only companies with a new report, a flag added or removed, average days to pay moving by your threshold (default 5 days), a change in e-invoicing or SCF, or a change in register status. Use a different `watchlistName` for each set of filters.
### Input
Every field is optional; the form groups them into **Mode**, **Which companies**, **Payment thresholds**, **Output & signal settings** and **Data sources**. Company numbers (watchlist) · name contains · latest report filed within N months (default 18) · SIC code prefixes · region (from registered-office postcode) · postcode areas · accounts category (size) · active only · minimum average days to pay · minimum % paid late · minimum % paid after 60 days · minimum maximum contractual term · minimum change in days to pay · minimum score · no e-invoicing · no SCF · trend · require any or all flags · sort · max results.
### Output (one row per company)
```json
{
"companyNumber": "00784278",
"companyName": "AMPHENOL LIMITED",
"latePaymentScore": 46,
"trend": "IMPROVING",
"flags": ["MAX_TERM_OVER_THRESHOLD", "HIGH_SHARE_PAID_LATE", "NO_SUPPLY_CHAIN_FINANCE"],
"avgDaysToPay": 59,
"avgDaysToPayChange": -8,
"pctInvoicesPaidOver60Days": 45,
"pctNotPaidWithinAgreedTerms": 57,
"maxContractualTermDays": 120,
"eInvoicingOffered": true,
"supplyChainFinanceOffered": false,
"reportingPeriodEnd": "2026-06-30",
"reportUrl": "https://check-payment-practices.service.gov.uk/report/113144",
"priorReportUrl": "https://check-payment-practices.service.gov.uk/report/98888",
"companyStatus": "Active",
"accountsCategory": "FULL",
"sicCodes": [{"code": "26110", "description": "Manufacture of electronic components"}],
"region": "South East",
"companiesHouseUrl": "https://find-and-update.company-information.service.gov.uk/company/00784278"
}
```
*(Illustrative excerpt. Rows have around 50 fields, including value paid late in GBP, payment-code membership, standard terms text, data-quality warnings and attribution.)*
Monitor-mode rows add `changeType` (`NEW_COMPANY`, `NEW_REPORT`, `SIGNAL_CHANGED` or `REGISTER_STATUS_CHANGED`), a readable `changes` list such as `"avgDaysToPay: 37 -> 51"`, and the `previous` values.
The dataset has three views: **AP / SCF prospects**, **Late payers** and **Changes**.
#### Flags
`AVG_DAYS_OVER_THRESHOLD`, `MAX_TERM_OVER_THRESHOLD`, `STANDARD_TERM_OVER_THRESHOLD` (threshold default 60 days, configurable) · `HIGH_SHARE_PAID_LATE` (≥30% not paid within terms by default) · `NO_E_INVOICING` · `NO_SUPPLY_CHAIN_FINANCE` · `WORSENING` · `CHARGED_SUPPLIERS_TO_STAY_ON_LIST` · `REGISTER_STATUS_NOT_ACTIVE` · `NO_PAYMENT_DATA` · `SUSPECT_DATA` (e.g. a reported average of 4,323,394 days)
#### Late-payment score (heuristic)
`0.4 × min(avgDaysToPay, 120)/120 × 100 + 0.3 × %notPaidWithinTerms + 0.2 × %paidOver60Days + 10 if WORSENING`, capped at 100. The score is not calculated when the reported average is implausible (over 365 days). It is a ranking aid, not a credit rating.
#### Trend
The latest report is compared with the company's previous report that contains payment data. `WORSENING` means at least +5 days or +10 percentage points paid late (both configurable). Where a company filed several reports for the same period, the most recently filed one is used.
### Data sources, licences and attribution
- **Payment practices reports**: Department for Business and Trade, *Payment Practices Reporting* service, downloaded fresh from the official export () and cached for 12 hours by default. *Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).* Figures are as reported by each business, in its own words. The government does not verify them.
- **Company register data**: **Companies House**, free *Basic Company Data* monthly snapshot (), cached per snapshot; for small runs, the public company overview page on (low concurrency, with backoff). Optionally, the Companies House Public Data API is used with **your own free API key** for companies missing from the live-company snapshot (e.g. dissolved). Companies House "impose\[s] no rules or requirements on how the information on the public register is used" and asks to be credited as the source (). This data is not under the OGL.
- This Actor is **not affiliated with or endorsed by** the Department for Business and Trade or Companies House.
#### No personal data
The output is company-level only. The Actor does **not** collect officers, directors, PSCs, the named person who approved a report, or street addresses. It keeps only the post town, postcode area and derived region. Narrative free-text answers are dropped, except the short "standard payment terms" statement, capped at 300 characters.
### Limitations
- Only companies and LLPs that meet the statutory "large" thresholds report: at least two of £54m turnover, £27m balance sheet and 250 employees. Small companies are not covered.
- The figures are self-reported and published with a delay. Reports cover six-month periods and are filed within 30 days of each period end, so filings peak in January and July.
- Regions are derived from postcode areas, which are approximate where areas cross region borders (e.g. SY, CH, DA, KT, TD).
- Around 5% of reporting companies are not in the live-company snapshot (mostly dissolved). Their rows have `companiesHouseSource: "not-found"` unless you supply an API key.
- **Run time.** Snapshot runs with *Max results* up to 200 and no sector/region/size/status filter look up register data only for the companies returned (from the cache, your Companies House API key if given, or the public Companies House company page) and usually finish in about a minute, even on a first run. In that mode `accountsCategory` is empty unless the company is already cached or you give an API key; set *Companies House lookup method* to *bulk* if you need it.
- Runs with sector/region/size/status filters, larger runs and monitor mode read the free monthly Companies House snapshot (about 0.5 GB). On the first run after a new snapshot that can take a few minutes; later runs use the cache and take seconds. If a run is close to its timeout, the snapshot scan stops early, rows are still delivered with whatever register data was reached, and the summary says `companiesHouseComplete: false`. Monitor runs never compare against incomplete register data.
- Each row has `companiesHouseStatus`, and `companiesHouseLookup` for found rows:
| `companiesHouseStatus` | Meaning | Charged? |
|---|---|---|
| `found` | Register data attached; `companiesHouseLookup` is `cache`, `bulk`, `api` or `page` | Yes |
| `not-on-register` | Lookup completed: Companies House says the company does not exist. In monitor mode (no per-company re-check) it means absent from the live-company snapshot, e.g. dissolved | Yes |
| `not-checked-time-limit` | Not looked up because the run was close to its timeout | **No (free row)** |
| `unavailable` | Companies House error, rate limit retries used up, rejected API key or unreadable page | **No (free row)** |
| `not-requested` | You turned *Join Companies House data* off | Yes |
`companiesHouseSource` is kept for compatibility (`bulk-snapshot-YYYY-MM-DD`, `public-data-api`, `companies-house-website`, otherwise the status value; it used to say `not-found`). The run summary (`OUTPUT`) reports `chargedRows`, `uncharged.notCheckedTimeLimit`, `uncharged.unavailable` and `companiesHouseStatusCounts`, and the status message repeats them. Free rows never count toward your max charge; delivery stops at the first row that would go over it.
### FAQ
**Is it legal to use this data commercially?**
Yes, with attribution. Both sources are official UK government publications:
- The payment practices reports are published by the Department for Business and Trade on GOV.UK, whose content is "available under the Open Government Licence v3.0, except where otherwise stated" (, footer). OGL v3 allows commercial reuse if you acknowledge the source (). Every row carries an `attribution` field you can keep.
- Companies House says: "We impose no rules or requirements on how the information on the public register is used" and that you are responsible for data protection, copyright and other law ().
The output is company-level only (no directors, officers or people), so it holds no personal data. This is not legal advice; check your own use case, in particular direct-marketing rules (PECR) if you contact companies.
**Does the Actor respect the sources' access rules?**
Yes. It reads the two free bulk files the government publishes for download (the payment practices CSV export and the monthly Companies House snapshot) and caches them in your account, so repeat runs within the cache window do not download them again. For small runs it opens at most 200 public Companies House company pages, three at a time with a pause and backoff on errors. Companies House asks that its searchable services are not used "as a source for bulk downloads" and may block anyone "generating unusually high numbers of daily database accesses" (, "Acceptable use"); large runs therefore always use the bulk snapshot instead. With your own free API key the Actor stays inside the Companies House API limit of 600 requests per 5 minutes () and backs off on HTTP 429.
**How fresh is it?**
The payment practices export is re-downloaded whenever the cache is older than `cacheHours` (default 12). Companies House data comes from the latest monthly snapshot or the live company page.
**How accurate is it?**
Each figure is copied from the company's own filing and every row links to it (`reportUrl`). Releases are spot-checked by comparing delivered rows with the live gov.uk report pages field by field. The figures themselves are self-reported and not audited by the government; rows with implausible values get the `SUSPECT_DATA` flag.
**Can I get every company?**
Yes. Set `maxReportAgeMonths: 0` and a high `maxResults`. There are about 10,000 companies.
**What happens if a source is down?**
If the payment practices export cannot be downloaded, the Actor uses the last good cached copy and says so in the run summary; with no cache it ends with a free notice row and charges nothing. If Companies House cannot be reached, rows are still delivered but marked `unavailable` and are free.
**Why did my monitor run return nothing?**
The first run on a watchlist only saves a baseline. Later runs return rows only when something changed.
### Related Actors
- [SEC Subsidiaries & Major Customers Scraper (EDGAR)](https://apify.com/Battles_2026/sec-subsidiary-map-concentration-risk): US public companies' subsidiaries and customers over 10% of revenue, each row quoted from the 10-K.
# Changelog
This Actor's version history is a separate document: https://apify.com/battles_2026/uk-late-payer-signals/changelog.md
# Actor input Schema
## `mode` (type: `string`):
Snapshot returns every matching company (charged per company signal). Monitor stores state in a named key-value store and returns only changes (charged per change alert). Schedule monitor runs daily or weekly.
## `watchlistName` (type: `string`):
Separate state is kept per watchlist name. Use a different name for each set of filters you monitor.
## `alertOn` (type: `string`):
Which changes produce an alert.
## `emitBaselineOnFirstRun` (type: `boolean`):
Off (recommended): the first monitor run only saves a baseline and returns nothing (no charge). On: the first run returns every matching company as NEW_COMPANY (charged as change alerts).
## `companyNumbers` (type: `array`):
Optional. Restrict to these Companies House numbers, e.g. 00784278, SC123456.
## `companyNameContains` (type: `string`):
Optional case-insensitive substring.
## `maxReportAgeMonths` (type: `integer`):
Only companies whose latest report was filed within this many months. 0 = no limit.
## `sicPrefixes` (type: `array`):
E.g. 41, 42, 43 (construction) or 62 (IT). Matches any of the company's SIC codes from Companies House.
## `regions` (type: `array`):
Derived from the registered-office postcode area (approximate at region borders).
## `postcodeAreas` (type: `array`):
E.g. M, LS, EC, G.
## `accountsCategories` (type: `array`):
Companies House accounts category of the last accounts filed (proxy for size).
## `activeOnly` (type: `boolean`):
Keep only companies with status 'Active' in the Companies House snapshot.
## `minAvgDaysToPay` (type: `integer`):
E.g. 60.
## `minPctNotPaidWithinTerms` (type: `integer`):
E.g. 30 = at least 30% of payments due were not paid within agreed terms.
## `minPctPaidOver60Days` (type: `integer`):
E.g. 20 = at least 20% of invoices took more than 60 days to pay.
## `minMaxContractualTermDays` (type: `integer`):
E.g. 61 to find companies with terms longer than the 60-day cap proposed in the Commercial Payments Bill.
## `minAvgDaysToPayChange` (type: `integer`):
E.g. 5 = paying at least 5 days slower than in the previous report.
## `minLatePaymentScore` (type: `integer`):
Heuristic 0-100 score (see README). E.g. 50.
## `onlyNoEInvoicing` (type: `boolean`):
Prospects for e-invoicing / AP automation vendors.
## `onlyNoSupplyChainFinance` (type: `boolean`):
Prospects for supply chain finance / early-payment providers.
## `trends` (type: `array`):
Trend of latest vs prior report.
## `requireAnyFlags` (type: `array`):
Keep companies having at least one of these flags.
## `requireAllFlags` (type: `array`):
Keep companies having all of these flags.
## `sortBy` (type: `string`):
Sort order of results.
## `maxResults` (type: `integer`):
Caps rows and therefore cost. Snapshot mode: max company signals. Monitor mode: max change alerts per run (alerts over the cap are kept pending and delivered next run). Snapshot runs of up to 200 rows without sector/region/size/status filters look up register data per company and finish in about a minute even on a cold start.
## `termThresholdDays` (type: `integer`):
Used for the \*\_OVER_THRESHOLD flags.
## `worseningThresholdDays` (type: `integer`):
Average-days-to-pay increase that counts as WORSENING.
## `worseningThresholdPctPoints` (type: `integer`):
Increase in % paid late (percentage points) that counts as WORSENING.
## `highLateSharePct` (type: `integer`):
High late share (% not paid within terms).
## `includeCompaniesHouse` (type: `boolean`):
Adds SIC codes, status, size category, town, region from the free Companies House bulk snapshot (cached per monthly snapshot; the first run of each month takes a few extra minutes).
## `chEnrichment` (type: `string`):
Auto: snapshot runs with Max results <= 200 and no sector/region/size/status filters look up only the returned companies (cached subset, then the Companies House API if you gave a key, then the public Companies House company page). Other runs read the free monthly bulk snapshot (~500 MB; a cold read takes a few minutes and is then cached).
## `companiesHouseApiKey` (type: `string`):
Optional free key from developer.company-information.service.gov.uk. Only used to look up companies missing from the live-company snapshot (e.g. dissolved). If empty, the COMPANIES_HOUSE_API_KEY environment variable of the Actor is used when set.
## `maxApiLookups` (type: `integer`):
Max Companies House API lookups.
## `cacheHours` (type: `integer`):
Re-download the official CSV if the cached copy is older than this.
## `forceRefresh` (type: `boolean`):
Force refresh all sources.
## `paymentPracticesCsvUrl` (type: `string`):
Override for testing. Leave empty: the Actor uses the official source URL.
## `companiesHouseBulkUrl` (type: `string`):
Override for testing. Leave empty: the Actor uses the official source URL.
## Actor input object example
```json
{
"mode": "snapshot",
"watchlistName": "default",
"alertOn": "materialChange",
"emitBaselineOnFirstRun": false,
"maxReportAgeMonths": 18,
"activeOnly": false,
"minAvgDaysToPay": 45,
"onlyNoEInvoicing": false,
"onlyNoSupplyChainFinance": false,
"sortBy": "latePaymentScore",
"maxResults": 20,
"termThresholdDays": 60,
"worseningThresholdDays": 5,
"worseningThresholdPctPoints": 10,
"highLateSharePct": 30,
"includeCompaniesHouse": true,
"chEnrichment": "auto",
"maxApiLookups": 300,
"cacheHours": 12,
"forceRefresh": false
}
```
# Actor output Schema
## `results` (type: `string`):
All dataset rows (company signals in snapshot mode, change alerts in monitor mode). Views: prospects, latePayers, changes.
## `summary` (type: `string`):
JSON summary of the run: mode, matching companies, signals/alerts delivered, data snapshot dates. Snapshot mode also records chargedRows, uncharged.notCheckedTimeLimit, uncharged.unavailable and companiesHouseStatusCounts.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "snapshot",
"maxReportAgeMonths": 18,
"minAvgDaysToPay": 45,
"sortBy": "latePaymentScore",
"maxResults": 20,
"includeCompaniesHouse": true
};
// Run the Actor and wait for it to finish
const run = await client.actor("battles_2026/uk-late-payer-signals").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "snapshot",
"maxReportAgeMonths": 18,
"minAvgDaysToPay": 45,
"sortBy": "latePaymentScore",
"maxResults": 20,
"includeCompaniesHouse": True,
}
# Run the Actor and wait for it to finish
run = client.actor("battles_2026/uk-late-payer-signals").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 '{
"mode": "snapshot",
"maxReportAgeMonths": 18,
"minAvgDaysToPay": 45,
"sortBy": "latePaymentScore",
"maxResults": 20,
"includeCompaniesHouse": true
}' |
apify call battles_2026/uk-late-payer-signals --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,battles_2026/uk-late-payer-signals"
}
}
}
```
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 ` 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/kfeHH5YspuL5WUnYu/builds/m5MnfxZrq4T3HPzMh/openapi.json