# London Gazette Strike Off Notices Scraper (`automation-lab/uk-gazette-strike-off-notices-monitor`) Actor

Search and monitor public London Gazette company strike-off pages with company references, notice stage, full cited PDF text, canonical URLs, and retrieval provenance.

- **URL**: https://apify.com/automation-lab/uk-gazette-strike-off-notices-monitor.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.56 / 1,000 notice page extracteds

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

## London Gazette Strike Off Notices Scraper

Search and monitor **London Gazette strike off notices** without an account or API key. The Actor finds official Gazette issue pages in a publication window, reads their cited PDFs, classifies the strike-off stage, and exports company names and registration numbers with complete retrieval provenance.

Each dataset item represents one Gazette page, not one company. A page can cite dozens of companies, exposed in `companyReferences` and counted in `companyCount`.

### What can this London Gazette strike-off monitor do?

- Search a date window for pages containing statutory strike-off language.
- Keep only proposed, final, retraction, or other strike-off pages.
- Filter cited text by a company name or registration number.
- Parse a known Gazette issue or supplement page directly.
- Export the complete PDF text alongside normalized fields.
- Preserve canonical page, PDF, search, issue, page, and retrieval references.
- Deduplicate pages by their stable Gazette URL.

The Actor currently limits discovery results to the **London** edition. Explicit URLs may point to London, Edinburgh, or Belfast issue pages.

### Who is this Actor for?

- Company-formation and registry platforms checking Gazette events.
- Credit-risk and supplier-monitoring teams.
- Accountants, insolvency specialists, and compliance analysts.
- Researchers building dated UK corporate-event datasets.
- Automation teams scheduling a daily run and comparing dataset rows.

This is a focused retrieval product. It does not submit DS01 forms, modify Companies House records, or send legal notices.

### Why use structured Gazette notice records?

The Gazette search result is a page-level public record, while the page PDF contains the complete statutory wording and company list. The Actor combines those official surfaces into one auditable row. You receive both normalized fields for filtering and the original cited content for verification.

No residential proxy, browser, login, or Companies House API key is required.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `noticeId` | Stable edition-issue-page identity |
| `noticeType` | `proposed-strike-off`, `final-strike-off`, `retraction`, or `other-strike-off` |
| `edition` | Gazette edition from the URL |
| `issueNumber` | Official issue number |
| `pageNumber` | Issue or supplement page number |
| `publicationDate` | Gazette publication date (`YYYY-MM-DD`) |
| `title` | Search result or issue-page title |
| `companyReferences` | Parsed company names and registration numbers |
| `companyCount` | Number of unique parsed registration numbers |
| `citedContent` | Full text extracted from the official PDF page |
| `canonicalUrl` | Public Gazette issue-page URL |
| `pdfUrl` | Official PDF used for extraction |
| `searchUrl` | Discovery query URL, or `null` for explicit URLs |
| `source` | `The Gazette` |
| `retrievedAt` | UTC retrieval timestamp |

### How to search recent strike-off notices

1. Choose a `startDate` and `endDate`.
2. Optionally select one or more `noticeTypes`.
3. Optionally enter a company name or number in `searchText`.
4. Set `maxItems` to the maximum number of Gazette pages you need.
5. Run the Actor and open the default dataset.
6. Schedule the same input daily for incremental monitoring.

Example:

```json
{
  "startDate": "2026-09-01",
  "endDate": "2026-09-14",
  "noticeTypes": ["proposed-strike-off"],
  "maxItems": 10
}
```

### How to extract a specific Gazette page

Provide `noticeUrls` when you already know the official issue-page URL:

```json
{
  "noticeUrls": [
    "https://www.thegazette.co.uk/London/issue/901095/supplement/4923"
  ],
  "startDate": "2026-09-01",
  "endDate": "2026-09-14",
  "maxItems": 1
}
```

Discovery search is skipped, but date, type, and text filters still apply. Non-Gazette hosts and unsupported URL shapes fail closed.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startDate` | string | Seven days ago | Earliest publication date |
| `endDate` | string | Today | Latest publication date |
| `searchText` | string | — | Case-insensitive filter over title and cited PDF text |
| `noticeTypes` | string\[] | All | Normalized stages to keep |
| `noticeUrls` | string\[] | — | Specific Gazette issue pages; disables discovery |
| `maxItems` | integer | 20 | Maximum accepted page records, from 1 to 500 |

Dates must use `YYYY-MM-DD`, and `startDate` cannot be later than `endDate`.

### Output example

A real page produces the following shape (content shortened here):

```json
{
  "noticeId": "London-901095-4923",
  "noticeType": "proposed-strike-off",
  "edition": "London",
  "issueNumber": "901095",
  "pageNumber": "4923",
  "publicationDate": "2026-09-08",
  "title": "The London Gazette, Supplement 901095, Page 4923",
  "companyReferences": [
    { "companyName": "S AND S FAMILY PARTNERSHIP LLP", "companyNumber": "OC430521" }
  ],
  "companyCount": 37,
  "citedContent": "COMPANIES ACT 2006 ...",
  "canonicalUrl": "https://www.thegazette.co.uk/London/issue/901095/supplement/4923",
  "pdfUrl": "https://www.thegazette.co.uk/London/issue/901095/supplement/4923/data.pdf",
  "searchUrl": null,
  "source": "The Gazette",
  "retrievedAt": "2026-09-14T06:30:00.000Z"
}
```

Use the full `citedContent` and official links when a decision requires source verification.

### How much does it cost to monitor London Gazette strike-off notices?

Pay-per-event billing has a one-time **$0.005 start event** plus one `item` event per accepted Gazette page. The current BRONZE `item` price is **$0.0076 per page**; higher account tiers receive the tier curve shown by Apify at run time.

At the current BRONZE price:

- 1 notice page costs about **$0.0126** including start.
- 10 notice pages cost about **$0.081** including start.
- 100 notice pages cost about **$0.765** including start.

A page may include many companies; embedded company references have no separate charge. Failed, duplicate, filtered, or non-strike-off pages do not emit an item event.

### Daily monitoring workflow

Use an Apify Schedule with a rolling date window:

1. Run shortly after Gazette publication.
2. Set the window wide enough to overlap the previous run.
3. Use `noticeId` or `canonicalUrl` as the deduplication key downstream.
4. Compare the current dataset with your saved notice IDs.
5. Review `noticeType`, `companyReferences`, and `citedContent` for new events.

The Actor exports records; it does not itself send alerts or maintain a cross-run state database.

### Spreadsheet and data-pipeline exports

Apify datasets can be downloaded as JSON, CSV, Excel, XML, or RSS. Arrays such as `companyReferences` are richest in JSON. For a flat spreadsheet, keep the notice-level row and expand the company array in your ETL tool.

Useful integration patterns include:

- Load page records into a compliance warehouse.
- Expand `companyReferences` into a company-event bridge table.
- Join `companyNumber` to an authorized Companies House workflow.
- Trigger review when a watched company number appears.
- Preserve `canonicalUrl`, `pdfUrl`, and `retrievedAt` in audit logs.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~uk-gazette-strike-off-notices-monitor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startDate":"2026-09-01","endDate":"2026-09-14","maxItems":3}'
```

To wait for output directly, use the synchronous dataset-items endpoint supported by the Apify API.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/uk-gazette-strike-off-notices-monitor').call({
  startDate: '2026-09-01',
  endDate: '2026-09-14',
  noticeTypes: ['final-strike-off'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/uk-gazette-strike-off-notices-monitor').call(run_input={
    'startDate': '2026-09-01',
    'endDate': '2026-09-14',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/uk-gazette-strike-off-notices-monitor"
```

#### Claude Desktop setup

Use this configuration in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/uk-gazette-strike-off-notices-monitor"
    }
  }
}
```

#### Cursor setup

Add the same `apify` server URL in **Cursor Settings → MCP**.

#### VS Code setup

Add the same HTTP MCP server to your VS Code MCP configuration and start it from the MCP servers panel.

Example prompts:

- “Find London Gazette strike-off pages published between 1 and 14 September 2026.”
- “Parse this Gazette supplement page and list its company numbers.”
- “Return only final strike-off pages and summarize the cited statutory wording.”

Always verify consequential conclusions against the returned source links.

### Reliability, retries, and failure behavior

Requests have a 30-second timeout and up to three bounded attempts for transient failures. Deterministic client errors are not retried blindly. One malformed page is logged and skipped so other discovered pages can complete.

The run fails for invalid date ranges, unsupported explicit URLs, or unrecoverable discovery errors. An explicit page without strike-off wording is rejected rather than emitted under a misleading type.

### Coverage and limitations

- Discovery currently emits London edition pages only.
- Explicit URLs can target London, Edinburgh, or Belfast pages.
- One dataset item is a Gazette page, which can contain many statutory sections.
- Company references are parsed from PDF text layout; inspect `citedContent` when `companyCount` is unexpectedly low.
- The Gazette can correct, replace, or retract notices after initial publication.
- This Actor monitors public records; it does not determine current legal company status.
- It does not file DS01 forms or query private Companies House services.

### Responsible and legal use

The Actor reads publicly accessible official Gazette pages and PDFs. Follow The Gazette's terms, Apify's policies, applicable database rights, privacy law, and your organization's retention rules. Do not treat automated output as legal advice or as a substitute for the current official record.

Keep provenance fields when redistributing results. Minimize personal-data processing when a page contains names or addresses that are not needed for your purpose.

### Troubleshooting

**Why did my run return no rows?**

The date window may contain no matching London pages, or your `noticeTypes`/`searchText` filter may exclude them. Broaden the window and remove optional filters before diagnosing a source failure.

**Why is `companyCount` lower than expected?**

Some PDFs use unusual layouts or continue a list across pages. Read `citedContent`, follow neighboring issue pages, and use the official PDF link for verification.

**Why was my explicit URL rejected?**

Use a public `thegazette.co.uk/{Edition}/issue/{number}/page/{number}` or `/supplement/{number}` URL. Search pages, PDFs, and third-party links are not accepted as canonical notice-page input.

### FAQ

**Does this include every Companies House filing?**\
No. It targets Gazette pages with strike-off wording, not the complete Companies House filing stream.

**Does `maxItems` limit companies?**\
No. It limits accepted Gazette page records. Each row can carry many company references.

**Can I monitor one company?**\
Yes. Put its exact company name or registration number in `searchText`, or provide a known issue-page URL.

**Can I schedule it daily?**\
Yes. Use an Apify Schedule and deduplicate downstream by `noticeId`.

**Is a successful match proof that a company is currently dissolved?**\
No. Notice wording and stage matter, and later notices or registry updates can supersede it.

### Related automation-lab Actors

This Actor is intentionally standalone because the portfolio does not currently contain another automation-lab Actor for the same Gazette notice workflow. Combine its company numbers with your own authorized registry, risk, notification, or warehouse integrations.

# Actor input Schema

## `startDate` (type: `string`):

Earliest publication date to include, in YYYY-MM-DD format. Defaults to seven days ago.

## `endDate` (type: `string`):

Latest publication date to include, in YYYY-MM-DD format. Defaults to today.

## `searchText` (type: `string`):

Optional case-insensitive text that must appear in the notice title or cited PDF content.

## `noticeTypes` (type: `array`):

Optional strike-off stages to keep. Leave empty to include proposed, final, retraction, and other strike-off pages.

## `noticeUrls` (type: `array`):

Optional London, Edinburgh, or Belfast Gazette issue page URLs. When supplied, discovery search is skipped; the same date, type, and text filters still apply.

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

Maximum Gazette issue-page notice records to save. Each record can reference many companies.

## Actor input object example

```json
{
  "startDate": "2026-09-01",
  "endDate": "2026-09-14",
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all accepted notice records.

# 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 = {
    "startDate": "2026-09-01",
    "endDate": "2026-09-14",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/uk-gazette-strike-off-notices-monitor").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 = {
    "startDate": "2026-09-01",
    "endDate": "2026-09-14",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/uk-gazette-strike-off-notices-monitor").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 '{
  "startDate": "2026-09-01",
  "endDate": "2026-09-14",
  "maxItems": 10
}' |
apify call automation-lab/uk-gazette-strike-off-notices-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/uk-gazette-strike-off-notices-monitor"
        }
    }
}
```

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/ExgSGNfSeyGX7QgFa/builds/0PB7BbfgBY6Jbtl4q/openapi.json