# UK Visa Sponsor Register: Search and Change Alerts (`datagleaner/uk-visa-sponsor-register`) Actor

Search the UK Home Office register of licensed visa sponsors (Skilled Worker, Global Business Mobility and more) by town, county, route, rating or name, or watch it for organisations added, removed or re-rated since your last run. $0.0005 per organisation, $0.002 per change.

- **URL**: https://apify.com/datagleaner/uk-visa-sponsor-register.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Lead generation, Business, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 sponsor listeds

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/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 Visa Sponsor Register: search licensed sponsors and get change alerts

Search the UK Home Office **register of licensed sponsors (workers, or the students register)** by town, county, route, rating or organisation name, and get one clean row per organisation. Or switch on **watch mode** and each run returns only the organisations **added, removed, re-rated or with changed routes** since your previous run.

The data is the official GOV.UK CSV "Register of licensed sponsors: workers" or "...: students" (set `register`), read fresh on every run. No browser, no proxy, no login.

Made for job seekers and recruiters who want employers that can sponsor a Skilled Worker or Global Business Mobility visa, immigration advisers and relocation firms who track who joins or loses a licence, and sales teams or AI agents that need a structured list of sponsor organisations.

### What you get

- **Organisation fields:** `organisationName`, `townCity`, `county`.
- **Licences:** `workerRating` and `temporaryWorkerRating` (A, B, Provisional and so on) and `routes` (Skilled Worker, Global Business Mobility: Senior or Specialist Worker, Creative Worker, Charity Worker, Religious Worker, International Sportsperson and the rest the register lists).
- **Watch mode extras:** `changeType` (`new`, `removed`, `ratingChanged`, `routesChanged`, and `statusChanged` for students), `previousWorkerRating`, `previousTemporaryWorkerRating`, `previousRoutes`, `previousRegisterDate`. Use `changeTypes` to keep only some of them.
- **Students register** (`"register": "students"`): `sponsorType` (Independent school, Higher Education Institution, Private provider and so on), `sponsorStatus` (Student Sponsor, Probationary Sponsor), `subjectToActionPlan`, `additionalLocations`, and `routes` (Student, Child Student). Filter by `sponsorTypes`; `ratings` matches the sponsor status. Watch mode keeps a separate baseline per register, so one store can hold both.
- **Provenance:** `registerDate`, `source`, `licence` and `attribution` on every row.

The register has one line per organisation, town, licence and route; this Actor groups them into one row per organisation and town.

### Input example

```json
{
  "towns": ["Manchester"],
  "routes": ["Skilled Worker"],
  "ratings": ["A"],
  "maxResults": 100
}
```

Watch mode (run it on a schedule, for example weekly):

```json
{
  "watchMode": true,
  "storeName": "sponsors-north-west",
  "towns": ["Manchester", "Liverpool"],
  "routes": ["Skilled Worker"]
}
```

The first watch run saves a free baseline of the whole register in the named store. Later runs compare against it, return the changes that match your filters, then move the baseline forward. If GOV.UK has not published a new file since your last run, the run says so and bills nothing. A run capped by `maxResults` or the charge limit does not advance the baseline, so no change is lost.

Leave the input empty to run a 5-row example (Skilled Worker sponsors in London).

### Output example

```json
{
  "mode": "search",
  "changeType": null,
  "organisationName": "Example Care Services Ltd",
  "townCity": "Manchester",
  "county": null,
  "workerRating": "A",
  "temporaryWorkerRating": null,
  "routes": ["Skilled Worker"],
  "registerDate": "2026-10-30",
  "source": "https://www.gov.uk/government/publications/register-of-licensed-sponsors-workers",
  "licence": "https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/",
  "attribution": "Contains public sector information licensed under the Open Government Licence v3.0 (Home Office, GOV.UK)",
  "scrapedAt": "2026-11-02T08:00:00Z"
}
```

### Pricing

Pay per result: **$0.0005 per organisation** returned in search mode and **$0.002 per change** in watch mode. Baseline, unchanged and error notice rows are free. Example: 2,000 care providers in a search cost $1.00; a weekly watch of one region that finds 40 changes costs $0.08. A run bills only what it returns, and `maxResults` and your run's maximum charge both cap it.

### Data source, licence and attribution

Source: the Home Office, "Register of licensed sponsors: workers", published on GOV.UK. Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/). If you republish the data, keep the attribution statement that comes in the `attribution` field. The Actor is independent and not endorsed by the Home Office or GOV.UK.

### Responsible use

- Ratings and licence status are reproduced as published; the Actor adds no judgement about any organisation. The register changes continuously, so check the official GOV.UK register before relying on a sponsor's status for a visa decision. This is not immigration or legal advice.
- The register is a list of organisations. Names that look like an individual (a sole trader such as "Mr A Smith" or "A Smith t/a Shop") are skipped, and no personal data is returned. The check is deliberately cautious, so a few small organisations with a two-word name and no business word may be skipped too. The Actor reports how many lines it skipped in its status message.
- Do not use the data to contact people in ways that break the law where they live; obligations for what you do with it rest with you.

### FAQ

**How fresh is it?** The Actor reads the file GOV.UK currently publishes, which the Home Office updates regularly (the file name carries its date, shown as `registerDate`).

**Does it include company websites or emails?** No. Rows are register fields only.

**Why was my town not matched?** Towns match the register's spelling exactly (case-insensitive). Use `query` or `counties` for broader searches.

**Can I watch several regions?** Yes: use a different `storeName` per watch.

# Actor input Schema

## `register` (type: `string`):

Which GOV.UK register of licensed sponsors to use. Watch mode keeps a separate baseline for each.

## `query` (type: `string`):

Case-insensitive text the organisation name must contain, e.g. `care`, `university`, `bank`.

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

Keep organisations in these towns or cities (exact name, case-insensitive), e.g. `Manchester`.

## `counties` (type: `array`):

Keep organisations in these counties as written in the register (many rows leave the county empty; use towns for those).

## `routes` (type: `array`):

Keep organisations licensed for a route that contains this text, e.g. `Skilled Worker`, `Senior or Specialist`, `Graduate Trainee`, `Creative Worker`, `Charity Worker`, `Religious Worker`, `International Sportsperson`. For the students register: `Student`, `Child Student`.

## `ratings` (type: `array`):

Keep organisations whose rating starts with one of these: `A`, `B`, `Provisional`. Matches the Worker licence unless you pick a licence type below. For the students register ratings match the sponsor status: `Student Sponsor`, `Probationary`.

## `licenceType` (type: `string`):

Restrict to organisations holding a Worker or a Temporary Worker licence. Ignored for the students register.

## `listAll` (type: `boolean`):

Return every organisation when no filter is set (about 100,000 rows, billed per row). Without any filter or this switch the Actor runs a 5-row example.

## `watchMode` (type: `boolean`):

Compare today's register with the copy saved by your previous run in the named store below and return only new, removed and re-rated organisations (filters still apply). The first run saves a baseline for free.

## `storeName` (type: `string`):

Named key-value store holding the previous register. Use a different name for each separate watch (for example one per town filter).

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

Stop after this many billed rows. In watch mode a capped run does not advance the baseline.

## `sponsorTypes` (type: `array`):

Students register only: keep sponsors whose type contains this text, e.g. `Independent school`, `Higher Education`, `Private provider`, `Publicly funded college`.

## `changeTypes` (type: `array`):

Watch mode: limit to these change types. Leave empty for all.

## Actor input object example

```json
{
  "register": "workers",
  "towns": [
    "Leeds",
    "Cardiff"
  ],
  "routes": [
    "Skilled Worker",
    "Global Business Mobility"
  ],
  "licenceType": "any",
  "listAll": false,
  "watchMode": false,
  "storeName": "uk-sponsor-register-watch",
  "maxResults": 10,
  "changeTypes": []
}
```

# 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 = {
    "towns": [
        "Manchester"
    ],
    "routes": [
        "Skilled Worker"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/uk-visa-sponsor-register").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 = {
    "towns": ["Manchester"],
    "routes": ["Skilled Worker"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/uk-visa-sponsor-register").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 '{
  "towns": [
    "Manchester"
  ],
  "routes": [
    "Skilled Worker"
  ],
  "maxResults": 10
}' |
apify call datagleaner/uk-visa-sponsor-register --silent --output-dataset

```

## MCP server setup

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

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/PzW47hyUHumZUh4wq/builds/dYhYwyUcj1GzdvfqK/openapi.json