# UK Sponsor Register Alerts: Licence Added or Removed (`accountable_eel/uk-sponsor-register-change-alerts`) Actor

Which UK employers gained or lost a Home Office sponsor licence since the last register update, with rating, routes and town, and a monitoring mode that returns and bills only changes you have not seen.

- **URL**: https://apify.com/accountable_eel/uk-sponsor-register-change-alerts.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 sponsor change returneds

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 Sponsor Register Alerts: Licence Added or Removed

**Find out which UK employers just gained or lost a Home Office sponsor licence.**
The Home Office publishes the register of licensed sponsors as one file that it replaces every week, and publishes no list of what changed. This actor keeps the last file it saw, compares it with the newest one, and returns one row per organisation added or removed, with its rating, routes (Skilled Worker and others) and town. Turn on monitoring and run it on a schedule to get, and pay for, only the changes you have not been given yet.

**Who uses it:** recruiters and agencies who want to approach employers the week they become able to sponsor, job boards and relocation services that flag "can sponsor a visa", immigration advisers watching a client's or competitor's licence, and sales teams selling to newly licensed employers.

**Related actors:** to check one named employer against the register today, use [UK Visa Sponsor Licence Check](https://apify.com/accountable_eel/uk-visa-sponsor-licence-check). This actor answers a different question: what changed.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `organisationNames` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~uk-sponsor-register-change-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"organisationNames":["<example>"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "organisationNames": []
}
```

One name or part of a name per line. Only sponsors whose registered name contains one of these are reported. Leave empty to see every sponsor added or removed. Accepted formats: Tesco, Barclays, care.

Leave the name list empty to see every change, or add names (or parts of names) to watch. Optional filters narrow by route (for example `Skilled Worker`), by town or county, and by added or removed. Filters apply before anything is returned or billed.

**The first run has nothing to compare.** gov.uk keeps only the current file, so the first run can only store it. Turn on "Return a sample of the current register" to get up to Max changes organisations as `LISTED` rows on that first run (billed like any row); otherwise the run returns nothing and is free. The first real changes arrive with the next weekly publication.

**Monitoring.** With "Only return changes I have not been given yet" on, each run returns only the changes from publications after the last one you were given; a run on an unchanged register returns one row with `changeCount: 0` and costs nothing. Name the watchlist (`deltaName`) to keep separate schedules apart. A sponsor that only moved to a different town is not reported as added or removed.

### Output

One row per sponsor change, for example:

| query | found | status | changeSummary | changeCount | truncated | monitorStatus | changes | changeType | organisationName | town | county | holdsSkilledWorkerLicence | rating | licenceTypes | routes | licences | registerDate | previousRegisterDate | registerFileUrl | sourceUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| example | true | OK | <what was compared> | <changes returned> | <more changes were available> | <monitoring status> | \<all changes (full list)> | <change> | <organisation> | \<town/city> | <county> | <skilled worker route> | <rating> | <licence types> | <routes> | \<licences (full detail)> | <register published> | <compared with> | <register file> | <source page> | 1970-01-01T00:00:00.000Z |

Example rows from a real run on the register published 2026-10-09 (a first run with the sample switched on, so the rows are `LISTED`; once a second publication exists, rows are `ADDED` or `REMOVED` and carry `previousRegisterDate`):

| changeType | organisationName | town | county | rating | routes | registerDate |
| --- | --- | --- | --- | --- | --- | --- |
| LISTED | AaruvikA Limited | Edinburgh | null | A | Skilled Worker | 2026-10-09 |
| LISTED | Asian African Foods Ltd | London | null | A | Skilled Worker | 2026-10-09 |
| LISTED | CORBY MUSLIM ASSOCIATION | Corby | null | A | Tier 2 Ministers of Religion | 2026-10-09 |

`changeType` is `ADDED` (on the newer register, not the older), `REMOVED` (the reverse) or `LISTED` (a sample row, only when you ask for one). `registerDate` is the publication the change was seen on and `previousRegisterDate` the one it was compared with. Missing values (`county`, `rating`) are `null`, never an empty string. A run with nothing to return comes back as a row with `"found": false` and is never charged.

### Pricing

- **Sponsor change returned**: $6 per 1,000 changes

Plus a $0.004 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

### Example runs

Paste any of these into the Input tab and press Start. None needs a key, a token or an account of your own beyond an Apify login.

**See what the register looks like now (first run).** Stores the register and returns a 20-organisation sample.

```json
{
  "emitBaseline": true,
  "maxItems": 20
}
```

**Newly licensed Skilled Worker sponsors in Leeds, each week.** Schedule it weekly; each run returns only the changes you have not seen.

```json
{
  "changeType": "added",
  "route": "Skilled Worker",
  "towns": ["Leeds"],
  "onlyNewSinceLastRun": true,
  "deltaName": "leeds-new-sponsors"
}
```

**Has a named employer lost its licence?**

```json
{
  "organisationNames": ["Tesco", "Barclays"],
  "changeType": "removed",
  "onlyNewSinceLastRun": true
}
```

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~uk-sponsor-register-change-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"organisationNames":["<example>"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~uk-sponsor-register-change-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"organisationNames":["<example>"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~uk-sponsor-register-change-alerts/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"organisationNames":["{{register comparison}}"]}`, mapping the row's register comparison into the `organisationNames` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "uk visa sponsor register changes" — the agent will find and run this actor.

# Actor input Schema

## `organisationNames` (type: `array`):

One name or part of a name per line. Only sponsors whose registered name contains one of these are reported. Leave empty to see every sponsor added or removed. Accepted formats: Tesco, Barclays, care. You're only charged for the ones we actually find — a miss costs nothing.

## `changeType` (type: `string`):

Added: organisations that appear on the newer register and not the older one. Removed: the reverse. A sponsor that only moved town is not reported as either.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `route` (type: `string`):

Optional. Keep sponsors holding a route whose name contains this text, for example Skilled Worker, Global Business Mobility or Health. Leave empty for every route.

## `towns` (type: `array`):

Optional. Keep sponsors whose town or county contains any of these, for example Leeds or Kent. Leave empty for the whole UK.

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

Up to 5000. Caps how many changes you get (and pay for) in one run. A weekly update can add or remove a few thousand sponsors.

## `emitBaseline` (type: `boolean`):

The Home Office publishes only the current register, so the very first run has nothing to compare. On: that run returns up to Max changes sponsors from the current register as LISTED rows (billed like any row). Off: it only stores the register and returns nothing.

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

On: each run returns only the changes from publications after the last one you were given, and a run with no new publication returns and bills nothing. Schedule it daily or weekly. Off: every run returns the latest comparison.

## `deltaName` (type: `string`):

Optional. Name this watchlist's memory so you can tell two schedules of this actor apart, or keep one memory across a filter change. Leave empty to derive one from your filters.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each change found gets its own row instead of being grouped under its register comparison. You're still only charged once per register comparison, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## Actor input object example

```json
{
  "organisationNames": [],
  "changeType": "all",
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "route": "",
  "towns": [],
  "maxItems": 100,
  "emitBaseline": false,
  "onlyNewSinceLastRun": false,
  "deltaName": "",
  "columns": [
    "changeSummary",
    "changeCount",
    "truncated",
    "monitorStatus",
    "changes",
    "changeType",
    "organisationName",
    "town",
    "county",
    "holdsSkilledWorkerLicence",
    "rating",
    "licenceTypes",
    "routes",
    "licences",
    "registerDate",
    "previousRegisterDate",
    "registerFileUrl",
    "sourceUrl"
  ],
  "expandRows": true,
  "maxConcurrency": 1
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "organisationNames": [],
    "includeKeywords": [],
    "excludeKeywords": [],
    "towns": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/uk-sponsor-register-change-alerts").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 = {
    "organisationNames": [],
    "includeKeywords": [],
    "excludeKeywords": [],
    "towns": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/uk-sponsor-register-change-alerts").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 '{
  "organisationNames": [],
  "includeKeywords": [],
  "excludeKeywords": [],
  "towns": []
}' |
apify call accountable_eel/uk-sponsor-register-change-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/uk-sponsor-register-change-alerts"
        }
    }
}
```

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/elBUWvD4Vbyon4FgH/builds/YEMyR8jNEHOz4urME/openapi.json